def manualsetEpgReload(self, answer): if answer: epgcache = eEPGCache.getInstance() epgcache.save() epgcache = eEPGCache.getInstance() epgcache.load() self.setBackup()
def doBackup(self):
configfile.save()
if config.plugins.softwaremanager.epgcache.value:
eEPGCache.getInstance().save()
try:
if path.exists(self.backuppath) == False:
makedirs(self.backuppath)
self.backupdirs = ' '.join( config.plugins.configurationbackup.backupdirs.value )
if not "/tmp/installed-list.txt" in self.backupdirs:
self.backupdirs = self.backupdirs + " /tmp/installed-list.txt"
if not "/tmp/changed-configfiles.txt" in self.backupdirs:
self.backupdirs = self.backupdirs + " /tmp/changed-configfiles.txt"
cmd1 = "opkg list-installed | egrep 'enigma2-plugin-|task-base|packagegroup-base' > /tmp/installed-list.txt"
cmd2 = "opkg list-changed-conffiles > /tmp/changed-configfiles.txt"
cmd3 = "tar -czvf " + self.fullbackupfilename + " " + self.backupdirs
cmd = [cmd1, cmd2, cmd3]
if path.exists(self.fullbackupfilename):
dt = str(date.fromtimestamp(stat(self.fullbackupfilename).st_ctime))
self.newfilename = self.backuppath + "/" + dt + '-' + self.backupfile
if path.exists(self.newfilename):
remove(self.newfilename)
rename(self.fullbackupfilename,self.newfilename)
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, Console, title = _("Backup is running..."), cmdlist = cmd,finishedCallback = self.backupFinishedCB,closeOnSuccess = True)
else:
self.session.open(Console, title = _("Backup is running..."), cmdlist = cmd,finishedCallback = self.backupFinishedCB, closeOnSuccess = True)
except OSError:
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, MessageBox, _("Sorry, your backup destination is not writeable.\nPlease select a different one."), MessageBox.TYPE_INFO, timeout = 10 )
else:
self.session.openWithCallback(self.backupErrorCB,MessageBox, _("Sorry, your backup destination is not writeable.\nPlease select a different one."), MessageBox.TYPE_INFO, timeout = 10 )
def EpgCacheChanged(configElement):
config.misc.epgcache_filename.setValue(os.path.join(config.misc.epgcachepath.value, config.misc.epgcachefilename.value.replace('.dat', '') + '.dat'))
config.misc.epgcache_filename.save()
eEPGCache.getInstance().setCacheFile(config.misc.epgcache_filename.value)
epgcache = eEPGCache.getInstance()
epgcache.save()
if not config.misc.epgcache_filename.value.startswith("/etc/enigma2/"):
if os.path.exists('/etc/enigma2/' + config.misc.epgcachefilename.value.replace('.dat', '') + '.dat'):
os.remove('/etc/enigma2/' + config.misc.epgcachefilename.value.replace('.dat', '') + '.dat')
def test_save(self): self.addCleanup(self.cleanup_save) testdb = "__test.db" self.oldfile = config.misc.epgcache_filename.value config.misc.epgcache_filename.value = resolveFilename(SCOPE_CONFIG, testdb) self._remove_db() print "saving to %s... " % (config.misc.epgcache_filename.value), config.misc.epgcache_filename.save() eEPGCache.getInstance().save()
def doBackup(self):
self.save_shutdownOK = config.usage.shutdownOK.value
config.usage.shutdownOK.setValue(True)
config.usage.shutdownOK.save()
configfile.save()
try:
if config.plugins.softwaremanager.epgcache.value:
eEPGCache.getInstance().save()
except:
pass
try:
if path.exists(self.backuppath) == False:
makedirs(self.backuppath)
InitConfig()
self.backupdirs=" ".join(f.strip("/") for f in config.plugins.configurationbackup.backupdirs_default.value)
for f in config.plugins.configurationbackup.backupdirs.value:
if not f.strip("/") in self.backupdirs:
self.backupdirs += " " + f.strip("/")
if not "tmp/installed-list.txt" in self.backupdirs:
self.backupdirs += " tmp/installed-list.txt"
if not "tmp/changed-configfiles.txt" in self.backupdirs:
self.backupdirs += " tmp/changed-configfiles.txt"
if not "tmp/passwd.txt" in self.backupdirs:
self.backupdirs += " tmp/passwd.txt"
if not "tmp/groups.txt" in self.backupdirs:
self.backupdirs += " tmp/groups.txt"
ShellCompatibleFunctions.backupUserDB()
pkgs=ShellCompatibleFunctions.listpkg(type="user")
installed = open("/tmp/installed-list.txt", "w")
installed.write('\n'.join(pkgs))
installed.close()
cmd2 = "opkg list-changed-conffiles > /tmp/changed-configfiles.txt"
cmd3 = "tar -C / -czvf " + self.fullbackupfilename + " " + self.backupdirs
for f in config.plugins.configurationbackup.backupdirs_exclude.value:
cmd3 = cmd3 + " --exclude " + f.strip("/")
for f in BLACKLISTED:
cmd3 = cmd3 + " --exclude " + f.strip("/")
cmd = [cmd2, cmd3]
if path.exists(self.fullbackupfilename):
dt = str(date.fromtimestamp(stat(self.fullbackupfilename).st_ctime))
self.newfilename = self.backuppath + "/" + dt + '-' + self.backupfile
if path.exists(self.newfilename):
remove(self.newfilename)
rename(self.fullbackupfilename,self.newfilename)
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, Console, title = _("Backup is running..."), cmdlist = cmd,finishedCallback = self.backupFinishedCB,closeOnSuccess = True)
else:
self.session.open(Console, title = _("Backup is running..."), cmdlist = cmd,finishedCallback = self.backupFinishedCB, closeOnSuccess = True)
except OSError:
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, MessageBox, _("Sorry, your backup destination is not writeable.\nPlease select a different one."), MessageBox.TYPE_INFO, timeout = 10 )
else:
self.session.openWithCallback(self.backupErrorCB,MessageBox, _("Sorry, your backup destination is not writeable.\nPlease select a different one."), MessageBox.TYPE_INFO, timeout = 10 )
def backupsettings(self, retval):
if retval:
if SystemInfo["canMultiBoot"]:
self.multibootslot = retval[0]
doBackup = retval[1] == "with backup"
else:
doBackup = retval == "with backup"
BACKUP_SCRIPT = "/usr/lib/enigma2/python/Plugins/Extensions/AutoBackup/settings-backup.sh"
def findmedia(destination):
def avail(path):
if not(SystemInfo["HasMMC"] and '/mmc' in path) and not os.path.islink(path):
try:
statvfs = os.statvfs(path)
return (statvfs.f_bavail * statvfs.f_frsize) / (1 << 20) >= 500 and path
except:
pass
for path in [destination] + getNonNetworkMediaMounts():
if avail(path):
return path
self.destination = findmedia(os.path.isfile(BACKUP_SCRIPT) and config.plugins.autobackup.where.value or "/media/hdd")
if self.destination:
destination = "/".join([self.destination, 'downloaded_images'])
self.zippedimage = "://" in self.source and "/".join([destination, self.imagename]) or self.source
self.unzippedimage = "/".join([destination, '%s.unzipped' % self.imagename[:-4]])
if os.path.isfile(destination):
os.remove(destination)
if not os.path.isdir(destination):
os.mkdir(destination)
if doBackup:
if os.path.isfile(BACKUP_SCRIPT):
self["info"].setText(_("Backing up to: %s") % self.destination)
configfile.save()
if config.plugins.autobackup.epgcache.value:
eEPGCache.getInstance().save()
self.containerbackup = Console()
self.containerbackup.ePopen("%s%s'%s' %s" % (BACKUP_SCRIPT, config.plugins.autobackup.autoinstall.value and " -a " or " ", self.destination, int(config.plugins.autobackup.prevbackup.value)), self.backupsettingsDone)
else:
self.session.openWithCallback(self.startDownload, MessageBox, _("Unable to backup settings as the AutoBackup plugin is missing, do you want to continue?"), default=False, simple=True)
else:
self.startDownload()
else:
self.session.openWithCallback(self.abort, MessageBox, _("Could not find suitable media - Please insert a media (e.g. USB stick) and try again!"), type=MessageBox.TYPE_ERROR, simple=True)
else:
self.abort()
def EpgSettingsChanged(configElement): mask = 0xffffffff if not config.epg.eit.value: mask &= ~(eEPGCache.NOWNEXT | eEPGCache.SCHEDULE | eEPGCache.SCHEDULE_OTHER) if not config.epg.mhw.value: mask &= ~eEPGCache.MHW if not config.epg.freesat.value: mask &= ~(eEPGCache.FREESAT_NOWNEXT | eEPGCache.FREESAT_SCHEDULE | eEPGCache.FREESAT_SCHEDULE_OTHER) if not config.epg.viasat.value: mask &= ~eEPGCache.VIASAT if not config.epg.netmed.value: mask &= ~(eEPGCache.NETMED_SCHEDULE | eEPGCache.NETMED_SCHEDULE_OTHER) eEPGCache.getInstance().setEpgSources(mask)
def cancel(self): nowTime = time.time() if nowTime > 1388534400: setRTCtime(nowTime) if config.plugins.SystemTime.choiceSystemTime.value == "0": eDVBLocalTimeHandler.getInstance().setUseDVBTime(True) else: eDVBLocalTimeHandler.getInstance().setUseDVBTime(False) try: eEPGCache.getInstance().timeUpdated() except: pass Console.cancel(self)
def startBackupsettings(self, retval):
if retval:
if os.path.isfile(self.BACKUP_SCRIPT):
self["info"].setText(_("Backing up to: %s") % self.destination)
configfile.save()
if config.plugins.autobackup.epgcache.value:
eEPGCache.getInstance().save()
self.containerbackup = Console()
self.containerbackup.ePopen("%s%s'%s' %s" % (self.BACKUP_SCRIPT, config.plugins.autobackup.autoinstall.value and " -a " or " ", self.destination, int(config.plugins.autobackup.prevbackup.value)), self.backupsettingsDone)
else:
self.session.openWithCallback(self.startDownload, MessageBox, _("Unable to backup settings as the AutoBackup plugin is missing, do you want to continue?"), default=False, simple=True)
else:
self.abort()
def update_schedule(self, result = None, retval = None, extra_args = None): if eDVBLocalTimeHandler.getInstance().ready(): nowTime = time() if nowTime > 1388534400: setRTCtime(nowTime) if config.plugins.SystemTime.choiceSystemTime.value == "0": eDVBLocalTimeHandler.getInstance().setUseDVBTime(True) else: eDVBLocalTimeHandler.getInstance().setUseDVBTime(False) try: eEPGCache.getInstance().timeUpdated() except: pass
def update_schedule(self, result = None, retval = None, extra_args = None): nowTime = time() if nowTime > 10000: print '[NTP]: setting E2 time:',nowTime setRTCtime(nowTime) if config.misc.SyncTimeUsing.value == "1": eDVBLocalTimeHandler.getInstance().setUseDVBTime(False) else: eDVBLocalTimeHandler.getInstance().setUseDVBTime(True) eEPGCache.getInstance().timeUpdated() self.timer.startLongTimer(int(config.misc.useNTPminutes.value) * 60) else: print 'NO TIME SET' self.timer.startLongTimer(10)
def setEpgReload(self, answer):
if answer:
epgcache = eEPGCache.getInstance()
epgcache.save()
epgcache = eEPGCache.getInstance()
epgcache.load()
self.updateDestination()
if config.plugins.epgrefresh_extra.save_backup.value and config.plugins.epgrefresh_extra.epgcachepath.value != "/etc/enigma2/":
restore_backup = config.misc.epgcache_filename.value + ".backup"
if os.path.exists(config.misc.epgcache_filename.value):
try:
os.system("cp -f %s %s" % (config.misc.epgcache_filename.value, restore_backup))
os.chmod("%s" % (restore_backup), 0644)
except:
pass
def doBackup(self):
configfile.save()
if config.plugins.softwaremanager.epgcache.value:
eEPGCache.getInstance().save()
try:
if not path.exists(self.backuppath):
makedirs(self.backuppath)
self.backupdirs = " ".join(config.plugins.configurationbackup.backupdirs.value)
if path.exists(self.fullbackupfilename):
dt = str(date.fromtimestamp(stat(self.fullbackupfilename).st_ctime))
self.newfilename = self.backuppath + "/" + dt + "-" + self.backupfile
if path.exists(self.newfilename):
remove(self.newfilename)
rename(self.fullbackupfilename, self.newfilename)
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
Console,
title=_("Backup is running..."),
cmdlist=["tar -czvf " + self.fullbackupfilename + " " + self.backupdirs],
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True,
)
else:
self.session.open(
Console,
title=_("Backup is running..."),
cmdlist=["tar -czvf " + self.fullbackupfilename + " " + self.backupdirs],
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True,
)
except OSError:
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."),
MessageBox.TYPE_INFO,
timeout=10,
)
else:
self.session.openWithCallback(
self.backupErrorCB,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."),
MessageBox.TYPE_INFO,
timeout=10,
)
def saveEpg():
epgcache = eEPGCache.getInstance()
epgcache.save()
return {
"result": True,
"message": ""
}
def getServicesNowNextEpg(sList):
ret = []
if not sList:
return { "events": ret, "result": False }
sRefList = sList.split(",")
search = ['IBDCTSERNX']
for service in sRefList:
search.append((service, 0, -1))
search.append((service, 1, -1))
epgcache = eEPGCache.getInstance()
events = epgcache.lookupEvent(search)
if events is not None:
for event in events:
ev = {}
ev['id'] = event[0]
ev['begin_timestamp'] = event[1]
ev['duration_sec'] = event[2]
ev['title'] = event[4]
ev['shortdesc'] = convertDesc(event[5])
ev['longdesc'] = convertDesc(event[6])
#if event[7] is not None:
# achannels = GetWithAlternative(event[7], False)
# if achannels:
# ev['asrefs'] = achannels
ev['sref'] = event[7]
ev['sname'] = filterName(event[8])
ev['now_timestamp'] = event[3]
ret.append(ev)
return { "events": ret, "result": True }
def getSearchSimilarEpg(ref, eventid):
ref = unquote(ref)
ret = []
ev = {}
epgcache = eEPGCache.getInstance()
events = epgcache.search(('IBDTSENR', 128, eEPGCache.SIMILAR_BROADCASTINGS_SEARCH, ref, eventid));
if events is not None:
for event in events:
ev = {}
ev['id'] = event[0]
ev['date'] = "%s %s" % (tstrings[("day_" + strftime("%w", (localtime(event[1]))))], strftime("%d.%m.%Y", (localtime(event[1]))))
ev['begin_timestamp'] = event[1]
ev['begin'] = strftime("%H:%M", (localtime(event[1])))
ev['duration_sec'] = event[2]
ev['duration'] = int(event[2] / 60)
ev['end'] = strftime("%H:%M",(localtime(event[1] + event[2])))
ev['title'] = event[3]
ev['shortdesc'] = convertDesc(event[4])
ev['longdesc'] = convertDesc(event[5])
ev['sref'] = event[7]
ev['sname'] = filterName(event[6])
ev['picon'] = getPicon(event[7])
ev['now_timestamp'] = None
ret.append(ev)
return { "events": ret, "result": True }
def getNowNextEpg(ref, servicetype):
ref = unquote(ref)
ret = []
epgcache = eEPGCache.getInstance()
events = epgcache.lookupEvent(['IBDCTSERNX', (ref, servicetype, -1)])
if events is not None:
for event in events:
ev = {}
ev['id'] = event[0]
if event[1]:
ev['begin_timestamp'] = event[1]
ev['duration_sec'] = event[2]
ev['title'] = event[4]
ev['shortdesc'] = convertDesc(event[5])
ev['longdesc'] = convertDesc(event[6])
ev['sref'] = event[7]
ev['sname'] = filterName(event[8])
ev['now_timestamp'] = event[3]
ev['remaining'] = (event[1] + event[2]) - event[3]
else:
ev['begin_timestamp'] = 0
ev['duration_sec'] = 0
ev['title'] = "N/A"
ev['shortdesc'] = ""
ev['longdesc'] = ""
ev['sref'] = event[7]
ev['sname'] = filterName(event[8])
ev['now_timestamp'] = 0
ev['remaining'] = 0
ret.append(ev)
return { "events": ret, "result": True }
def __init__(self, session, service=None, event=None):
Screen.__init__(self, session)
global instance
instance = self
self.session = session
self.skinName = [ "SeriesPluginInfoScreen" ]
self["logo"] = Pixmap()
self["cover"] = Pixmap()
self["state"] = Pixmap()
self["event_title"] = Label()
self["event_episode"] = Label()
self["event_description"] = ScrollLabel()
self["datetime"] = Label()
self["channel"] = Label()
self["duration"] = Label()
self["key_red"] = Button("") # Rename or Record
self["key_green"] = Button("") # Trakt Seen / Not Seen
self["key_yellow"] = Button("") # Show all Episodes of current season
self["key_blue"] = Button("") # Show all Seasons
self.redButtonFunction = None
#TODO HelpableActionMap
self["actions"] = ActionMap(["OkCancelActions", "EventViewActions", "DirectionActions", "ColorActions"],
{
"cancel": self.close,
"ok": self.close,
"up": self["event_description"].pageUp,
"down": self["event_description"].pageDown,
"red": self.redButton,
"prevEvent": self.prevEpisode,
"nextEvent": self.nextEpisode,
#TODO
#"pageUp": self.pageUp,
#"pageDown": self.pageDown,
#"openSimilarList": self.openSimilarList
})
splog("SPI: SeriesPluginInfo", service, event)
self.service = service
self.event = event
self.name = ""
self.short = ""
self.data = None
self.path = None
self.eservice = None
self.epg = eEPGCache.getInstance()
self.serviceHandler = eServiceCenter.getInstance()
self.seriesPlugin = getInstance()
self.onLayoutFinish.append( self.layoutFinished )
def getBouquetEpg(ref, begintime=-1, endtime=None):
ref = unquote(ref)
ret = []
services = eServiceCenter.getInstance().list(eServiceReference(ref))
if not services:
return { "events": ret, "result": False }
search = ['IBDCTSERN']
for service in services.getContent('S'):
if endtime:
search.append((service, 0, begintime, endtime))
else:
search.append((service, 0, begintime))
epgcache = eEPGCache.getInstance()
events = epgcache.lookupEvent(search)
if events is not None:
for event in events:
ev = {}
ev['id'] = event[0]
ev['begin_timestamp'] = event[1]
ev['duration_sec'] = event[2]
ev['title'] = event[4]
ev['shortdesc'] = convertDesc(event[5])
ev['longdesc'] = convertDesc(event[6])
ev['sref'] = event[7]
ev['sname'] = filterName(event[8])
ev['now_timestamp'] = event[3]
ret.append(ev)
return { "events": ret, "result": True }
def loadepg(self, result, retval, extra_args):
if retval is 0:
epgcache = new.instancemethod(_enigma.eEPGCache_load,None,eEPGCache)
epgcache = eEPGCache.getInstance().load()
self.mbox = self.session.open(MessageBox,(_("EPG downloaded")), MessageBox.TYPE_INFO, timeout = 4 )
else:
self.mbox = self.session.open(MessageBox,(_("Sorry, the EPG download error")), MessageBox.TYPE_INFO, timeout = 4 )
def __init__(self, type):
Converter.__init__(self, type)
self.epgcache = eEPGCache.getInstance()
args = type.split(',')
if len(args) != 2:
raise ElementError("type must contain exactly 2 arguments")
type = args.pop(0)
showDuration = args.pop(0)
if type == "Event1":
self.type = self.Event1
elif type == "Event2":
self.type = self.Event2
elif type == "Event3":
self.type = self.Event3
elif type == "PrimeTime":
self.type = self.PrimeTime
else:
self.type = self.Event0
if showDuration == "noDuration":
self.showDuration = self.noDuration
elif showDuration == "onlyDuration":
self.showDuration = self.onlyDuration
elif showDuration == "showDuration":
self.showDuration = self.withDuration
elif showDuration == "shortDescription":
self.showDuration = self.shortDescription
else:
self.showDuration = self.longDescription
def loadEpg():
epgcache = eEPGCache.getInstance()
epgcache.load()
return {
"result": True,
"message": ""
}
def __init__(self, type): Converter.__init__(self, type) self.epgcache = eEPGCache.getInstance() if type == "Description": self.type = self.SHORT_DESCRIPTION elif type == "ExtendedDescription": self.type = self.EXTENDED_DESCRIPTION elif type == "FullDescription": self.type = self.FULL_DESCRIPTION elif type == "ID": self.type = self.ID elif type == "NameNow" or type == "NowName": self.type = self.NAME_NOW elif type == "NameNext" or type == "NextName": self.type = self.NAME_NEXT elif type == "Genre": self.type = self.GENRE elif type == "Rating": self.type = self.RATING elif type == "SmallRating": self.type = self.SRATING elif type == "NextDescription": self.type = self.NEXT_DESCRIPTION elif type == "ThirdName": self.type = self.THIRD_NAME elif type == "ThirdDescription": self.type = self.THIRD_DESCRIPTION else: self.type = self.NAME
def updateEpgCache(self):
config.misc.epgcache_filename.setValue(os.path.join(config.plugins.epgrefresh_extra.epgcachepath.value, config.plugins.epgrefresh_extra.epgcachefilename.value.replace(".dat","") + ".dat"))
config.misc.epgcache_filename.save()
configfile.save()
if self.prev_lastepgcachepath != config.misc.epgcache_filename.value:
eEPGCache.getInstance().setCacheFile(config.misc.epgcache_filename.value)
eEPGCache.getInstance().save()
self.updateDestination()
if config.plugins.epgrefresh_extra.save_backup.value and config.plugins.epgrefresh_extra.epgcachepath.value != "/etc/enigma2/":
restore_backup = config.misc.epgcache_filename.value + ".backup"
if os.path.exists(config.misc.epgcache_filename.value):
try:
os.system("cp -f %s %s" % (config.misc.epgcache_filename.value, restore_backup))
os.chmod("%s" % (restore_backup), 0644)
except:
pass
def __init__(self, selChangedCB = None, timer = None, time_epoch = 120, overjump_empty = True):
GUIComponent.__init__(self)
self.cur_event = None
self.cur_service = None
self.offs = 0
self.timer = timer
self.last_time = time()
self.onSelChanged = [ ]
if selChangedCB is not None:
self.onSelChanged.append(selChangedCB)
self.l = eListboxPythonMultiContent()
self.l.setBuildFunc(self.buildEntry)
self.setOverjump_Empty(overjump_empty)
self.epgcache = eEPGCache.getInstance()
self.clocks = [ LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_add.png')),
LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_pre.png')),
LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock.png')),
LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_prepost.png')),
LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_post.png')) ]
self.time_base = None
self.time_epoch = time_epoch
self.list = None
self.select_rect = None
self.event_rect = None
self.service_rect = None
self.picon_size = None
self.currentlyPlaying = None
self.showPicon = False
self.showServiceTitle = True
self.picload = ePicLoad()
self.nowEvPix = None
self.othEvPix = None
self.selEvPix = None
self.recEvPix = None
self.curSerPix = None
self.foreColor = 0xffffff
self.foreColorSelected = 0xffc000
self.borderColor = 0x464445
self.backColor = 0x595959
self.backColorSelected = 0x808080
self.foreColorService = 0xffffff
self.foreColorServiceSelected = 0xffffff
self.backColorService = 0x000000
self.backColorServiceSelected = 0x508050
self.borderColorService = 0x000000
self.foreColorNow = 0xffffff
self.backColorNow = 0x505080
self.foreColorRec = 0xffffff
self.backColorRec = 0x805050
self.serviceFont = gFont("Regular", 20)
self.entryFontName = "Regular"
self.entryFontSize = 18
self.listHeight = None
self.listWidth = None
self.serviceBorderWidth = 1
self.serviceNamePadding = 0
self.eventBorderWidth = 1
self.eventNamePadding = 0
def keyGo(self, result = None):
self.getConfigListValues()
if self.timer.eit is not None:
event = eEPGCache.getInstance().lookupEventId(self.timer.service_ref.ref, self.timer.eit)
if event:
n = event.getNumOfLinkageServices()
if n > 1:
tlist = []
ref = self.session.nav.getCurrentlyPlayingServiceReference()
parent = self.timer.service_ref.ref
selection = 0
for x in range(n):
i = event.getLinkageService(parent, x)
if i.toString() == ref.toString():
selection = x
tlist.append((i.getName(), i))
self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice to record..."), list = tlist, selection = selection)
return
elif n > 0:
parent = self.timer.service_ref.ref
self.timer.service_ref = ServiceReference(event.getLinkageService(parent, 0))
if self.timerentry_plugins:
self.timer.plugins = {}
for key, val in self.timerentry_plugins.iteritems():
self.timer.plugins[val[0]] = (str(key[1].value),str(val[2]))
print "timerentry self.timer.plugins", self.timer.plugins
self.saveTimer()
self.close((True, self.timer))
def searchEPG(self, searchString = None, searchSave = True):
if searchString:
self.currSearch = searchString
if searchSave:
# Maintain history
history = config.plugins.epgsearch.history.value
if searchString not in history:
history.insert(0, searchString)
maxLen = config.plugins.epgsearch.history_length.value
if len(history) > maxLen:
del history[maxLen:]
else:
history.remove(searchString)
history.insert(0, searchString)
# Workaround to allow search for umlauts if we know the encoding (pretty bad, I know...)
encoding = config.plugins.epgsearch.encoding.value
searchString = searchString.replace('\xc2\x86', '').replace('\xc2\x87', '')
if encoding != 'UTF-8':
try:
searchString = searchString.decode('UTF-8').encode(encoding)
except (UnicodeDecodeError, UnicodeEncodeError):
pass
# Search EPG, default to empty list
epgcache = eEPGCache.getInstance() # XXX: the EPGList also keeps an instance of the cache but we better make sure that we get what we want :-)
ret = epgcache.search(('RIBDT', 1000, eEPGCache.PARTIAL_TITLE_SEARCH, searchString, eEPGCache.NO_CASE_CHECK)) or []
ret.sort(key=itemgetter(2)) # sort by time
# Update List
l = self["list"]
l.recalcEntrySize()
l.list = ret
l.l.setList(ret)
def __init__(self, selChangedCB=None, timer=None, time_epoch=120, overjump_empty=True):
self.cur_event = None
self.cur_service = None
self.offs = 0
self.timer = timer
self.onSelChanged = []
if selChangedCB is not None:
self.onSelChanged.append(selChangedCB)
GUIComponent.__init__(self)
self.l = eListboxPythonMultiContent()
self.l.setItemHeight(54)
self.l.setBuildFunc(self.buildEntry)
if overjump_empty:
self.l.setSelectableFunc(self.isSelectable)
self.epgcache = eEPGCache.getInstance()
self.clock_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock.png"))
self.clock_add_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_add.png"))
self.clock_pre_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_pre.png"))
self.clock_post_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_post.png"))
self.clock_prepost_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_prepost.png"))
self.time_base = None
self.time_epoch = time_epoch
self.list = None
self.event_rect = None
self.foreColor = None
self.foreColorSelected = None
self.borderColor = None
self.backColor = 0x586D88
self.backColorSelected = 0x808080
self.foreColorService = None
self.backColorService = None
def currentEventTime(self): remaining = 0 ref = self.session.nav.getCurrentlyPlayingServiceReference() if ref: path = ref.getPath() if path: # Movie service = self.session.nav.getCurrentService() seek = service and service.seek() if seek: length = seek.getLength() position = seek.getPlayPosition() if length and position: remaining = length[1] - position[1] if remaining > 0: remaining = remaining / 90000 else: # DVB epg = eEPGCache.getInstance() event = epg.lookupEventTime(ref, -1, 0) if event: now = int(time()) start = event.getBeginTime() duration = event.getDuration() end = start + duration remaining = end - now if remaining > 0: return remaining + config.recording.margin_after.value * 60 return remaining
def prepareRefresh(self):
print("[EPGRefresh] About to start refreshing EPG")
try:
self.readConfiguration()
except Exception as e:
print("[EPGRefresh] Error occured while reading in configuration:", e)
if len(self.services[0]) == 0 and len(self.services[1]) == 0:
self.isrunning = False
return
self.scanServices = self.generateServicelist(self.services[0], self.services[1])
print("[EPGRefresh] Services we're going to scan:", ', '.join([repr(x) for x in self.scanServices]))
self.maybeStopAdapter()
if config.plugins.epgrefresh.adapter.value == "main":
refreshAdapter = MainPictureAdapter(self.session)
elif config.plugins.epgrefresh.adapter.value == "record":
refreshAdapter = RecordAdapter(self.session)
else:
if config.plugins.epgrefresh.adapter.value == "pip":
hidden = False
elif config.plugins.epgrefresh.adapter.value == "pip_hidden":
hidden = True
refreshAdapter = PipAdapter(self.session, hide=hidden)
if (not refreshAdapter.backgroundCapable and Screens.Standby.inStandby) or not refreshAdapter.prepare():
print("[EPGRefresh] Adapter is not able to run in background or not available, falling back to MainPictureAdapter")
refreshAdapter = MainPictureAdapter(self.session)
refreshAdapter.prepare()
self.refreshAdapter = refreshAdapter
self.isrunning = True
if config.plugins.epgrefresh.erase.value:
print("[EPGRefresh] flushing EPG cache...")
from enigma import eEPGCache
epgcache = eEPGCache.getInstance()
epgcache.flushEPG()
self.refresh()
print("[EPGRefresh] pre start...")
def LSTE(self, args):
args = args.split()
first = args and args.pop(0)
#TODO: find out format of "at <time>"
if not first or first in ('now', 'next',
'at') or args and args[1] == "at":
# XXX: "parameter not implemented" might be weird to say in case of no parameters, but who cares :-)
payload = "%d parameter not implemented" % (CODE_IMP_PARAM, )
return self.sendLine(payload)
try:
channelId = int(first) - 1
service = self.channelList[channelId]
except ValueError:
# XXX: add support for sref
payload = "%d parameter not implemented" % (CODE_IMP_PARAM, )
return self.sendLine(payload)
# handle additional parametes "now" and "next"
type = 0
time = -1
endtime = -1
options = "IBDTSERN"
if args:
options = "IBDTSERNX"
if args[0] == "now":
type = 0
endtime = None
elif args[0] == "next":
type = 1
endtime = None
# fetch data
epgcache = eEPGCache.getInstance()
if endtime is None:
params = (service, type, time)
else:
params = (service, type, time, endtime)
events = epgcache.lookupEvent([options, params])
if not events:
return self.sendLine("550 No schedule found")
# process data
def sendEventLine(eit, begin, duration, title, description, extended,
sref, sname):
payload = "%d-E %d %d %d 0" % (CODE_EPG, eit, begin, duration)
self.sendLine(payload)
payload = "%d-T %s" % (CODE_EPG, title)
self.sendLine(payload)
payload = "%d-S %s" % (CODE_EPG, description)
self.sendLine(payload)
payload = "%d-D %s" % (CODE_EPG, extended.replace('\xc2\x8a', '|'))
self.sendLine(payload)
payload = "%d-e" % (CODE_EPG, )
self.sendLine(payload)
lastItem = events.pop()
payload = "%d-C %s %s" % (CODE_EPG, lastItem[-2], lastItem[-1])
self.sendLine(payload)
for event in events:
sendEventLine(*event)
sendEventLine(*lastItem)
payload = "%d-c" % (CODE_EPG, )
self.sendLine(payload)
payload = "%d End of EPG data" % (CODE_EPG, )
self.sendLine(payload)
def check_and_add_event(self, neweventid):
if not config.plugins.vps.allow_seeking_multiple_pdc.value:
return
epgcache = eEPGCache.getInstance()
evt = epgcache.lookupEventId(self.rec_ref, neweventid)
if evt:
evt_begin = evt.getBeginTime() + 60
evt_end = evt.getBeginTime() + evt.getDuration() - 60
if evt_begin < self.timer.begin:
return
for checktimer in self.session.nav.RecordTimer.timer_list:
if checktimer == self.timer:
continue
if (checktimer.begin - evt_begin) > 3600 * 2:
break
compareString = checktimer.service_ref.ref.toCompareString()
if compareString == self.timer.service_ref.ref.toCompareString(
) or compareString == self.rec_ref.toCompareString():
if checktimer.eit == neweventid:
return
if checktimer.begin <= evt_begin and checktimer.end >= evt_end:
if checktimer.vpsplugin_enabled is None or not checktimer.vpsplugin_enabled:
return
# manuell angelegter Timer mit VPS
if checktimer.name == "" and checktimer.vpsplugin_time is not None:
checktimer.eit = neweventid
checktimer.name = evt.getEventName()
checktimer.description = evt.getShortDescription()
checktimer.vpsplugin_time = None
checktimer.log(
0,
"[VPS] changed timer (found same PDC-Time as in other VPS-recording)"
)
return
# eigenen Timer überprüfen, wenn Zeiten nicht überschrieben werden dürfen
if not self.timer.vpsplugin_overwrite and evt_begin <= self.timer.end:
check_already_existing = [
x for (x, y) in self.next_events if y == neweventid
]
if len(check_already_existing) > 0:
start = check_already_existing.pop()
if start == evt_begin:
return
else:
self.next_events.remove((start, neweventid))
self.timer.log(
0, "[VPS] delete event_id " + str(neweventid) +
" because of delay " + str(evt_begin - start))
self.next_events.append((evt_begin, neweventid))
self.next_events = sorted(self.next_events)
self.timer.log(0, "[VPS] add event_id " + str(neweventid))
else:
newevent_data = parseEvent(evt)
newEntry = RecordTimerEntry(ServiceReference(self.rec_ref),
*newevent_data)
newEntry.vpsplugin_enabled = True
newEntry.vpsplugin_overwrite = True
newEntry.dirname = self.timer.dirname
newEntry.log(
0,
"[VPS] added this timer (found same PDC-Time as in other VPS-recording)"
)
# Wenn kein Timer-Konflikt auftritt, wird der Timer angelegt.
res = NavigationInstance.instance.RecordTimer.record(newEntry)
self.timer.log(0, "[VPS] added another timer, res " + str(res))
def SaveEPG(self):
from enigma import eEPGCache
epgcache = eEPGCache.getInstance()
epgcache.save()
def backupsettings(self, retval):
if retval:
if SystemInfo["canMultiBoot"]:
self.multibootslot = retval
BACKUP_SCRIPT = "/usr/lib/enigma2/python/Plugins/Extensions/AutoBackup/settings-backup.sh"
def findmedia(destination):
def avail(path):
if os.path.isdir(path) and not os.path.islink(
path) and not (SystemInfo["HasMMC"]
and '/mmc' in path):
statvfs = os.statvfs(path)
return (statvfs.f_bavail *
statvfs.f_frsize) / (1 << 20) >= 500 and path
for path in [destination] + [
'/media/%s' % x for x in os.listdir('/media')
]:
if avail(path):
return path
self.destination = findmedia(
os.path.isfile(BACKUP_SCRIPT)
and config.plugins.autobackup.where.value or "/media/hdd")
if self.destination:
destination = "/".join([self.destination, 'downloaded_images'])
self.zippedimage = "://" in self.source and "/".join(
[destination, self.imagename]) or self.source
self.unzippedimage = "/".join(
[destination,
'%s.unzipped' % self.imagename[:-4]])
if os.path.isfile(destination):
os.remove(destination)
if not os.path.isdir(destination):
os.mkdir(destination)
if os.path.isfile(BACKUP_SCRIPT):
self["info"].setText(
_("Backing up to: %s") % self.destination)
configfile.save()
if config.plugins.autobackup.epgcache.value:
eEPGCache.getInstance().save()
self.containerbackup = Console()
self.containerbackup.ePopen(
"%s%s'%s' %s" %
(BACKUP_SCRIPT,
config.plugins.autobackup.autoinstall.value and " -a "
or " ", self.destination,
int(config.plugins.autobackup.prevbackup.value)),
self.backupsettingsDone)
else:
self.session.openWithCallback(
self.startDownload,
MessageBox,
_("Unable to backup settings as the AutoBackup plugin is missing, do you want to continue?"
),
default=False,
simple=True)
else:
self.session.openWithCallback(
self.abort,
MessageBox,
_("Could not find suitable media - Please insert a media (e.g. USB stick) and try again!"
),
type=MessageBox.TYPE_ERROR,
simple=True)
else:
self.abort()
def getInfo(session=None, need_fullinfo=False):
# TODO: get webif versione somewhere!
info = {}
global STATICBOXINFO
if not (STATICBOXINFO is None or need_fullinfo):
return STATICBOXINFO
info['brand'] = getMachineBrand()
info['model'] = getMachineName()
info['boxtype'] = getBoxType()
info['machinebuild'] = getMachineBuild()
chipset = "unknown"
if fileExists("/etc/.box"):
f = open("/etc/.box", 'r')
model = f.readline().strip().lower()
f.close()
if model.startswith("ufs") or model.startswith("ufc"):
if model in ("ufs910", "ufs922", "ufc960"):
chipset = "SH4 @266MHz"
else:
chipset = "SH4 @450MHz"
elif model in ("topf", "tf7700hdpvr"):
chipset = "SH4 @266MHz"
elif model.startswith("azbox"):
f = open("/proc/stb/info/model", 'r')
model = f.readline().strip().lower()
f.close()
if model == "me":
chipset = "SIGMA 8655"
elif model == "minime":
chipset = "SIGMA 8653"
else:
chipset = "SIGMA 8634"
elif model.startswith("spark"):
if model == "spark7162":
chipset = "SH4 @540MHz"
else:
chipset = "SH4 @450MHz"
elif fileExists("/proc/stb/info/azmodel"):
f = open("/proc/stb/info/model", 'r')
model = f.readline().strip().lower()
f.close()
if model == "me":
chipset = "SIGMA 8655"
elif model == "minime":
chipset = "SIGMA 8653"
else:
chipset = "SIGMA 8634"
elif fileExists("/proc/stb/info/model"):
f = open("/proc/stb/info/model", 'r')
model = f.readline().strip().lower()
f.close()
if model == "tf7700hdpvr":
chipset = "SH4 @266MHz"
elif model == "nbox":
chipset = "STi7100 @266MHz"
elif model == "arivalink200":
chipset = "STi7109 @266MHz"
elif model in ("adb2850", "adb2849", "dsi87"):
chipset = "STi7111 @450MHz"
elif model in ("sagemcom88", "esi88"):
chipset = "STi7105 @450MHz"
elif model.startswith("spark"):
if model == "spark7162":
chipset = "STi7162 @540MHz"
else:
chipset = "STi7111 @450MHz"
elif model == "dm800":
chipset = "bcm7401"
info['model'] = "DM800 HD PVR"
if fileExists("/proc/stb/info/chipset"):
f = open("/proc/stb/info/chipset", 'r')
chipset = f.readline().strip()
f.close()
info['chipset'] = chipset
memFree = 0
for line in open("/proc/meminfo", 'r'):
parts = line.split(':')
key = parts[0].strip()
if key == "MemTotal":
info['mem1'] = parts[1].strip().replace("kB", _("kB"))
elif key in ("MemFree", "Buffers", "Cached"):
memFree += int(parts[1].strip().split(' ', 1)[0])
info['mem2'] = "%s %s" % (memFree, _("kB"))
info['mem3'] = _("%s free / %s total") % (info['mem2'], info['mem1'])
try:
f = open("/proc/uptime", "rb")
uptime = int(float(f.readline().split(' ', 2)[0].strip()))
f.close()
uptimetext = ''
if uptime > 86400:
d = uptime / 86400
uptime = uptime % 86400
uptimetext += '%dd ' % d
uptimetext += "%d:%.2d" % (uptime / 3600, (uptime % 3600) / 60)
except:
uptimetext = "?"
info['uptime'] = uptimetext
info["webifver"] = getOpenWebifVer()
info['imagedistro'] = getImageDistro()
info['friendlyimagedistro'] = getFriendlyImageDistro()
info['oever'] = getOEVersion()
info['imagever'] = getImageVersion()
ib = getImageBuild()
if ib:
info['imagever'] = info['imagever'] + "." + ib
info['enigmaver'] = getEnigmaVersionString()
info['driverdate'] = getDriverDate()
info['kernelver'] = about.getKernelVersionString()
try:
from Tools.StbHardware import getFPVersion
except ImportError:
from Tools.DreamboxHardware import getFPVersion
try:
info['fp_version'] = getFPVersion()
except:
info['fp_version'] = None
friendlychipsetdescription = _("Chipset")
friendlychipsettext = info['chipset'].replace("bcm", "Broadcom ")
if friendlychipsettext in ("7335", "7356", "7362", "73625", "7424", "7425",
"7429"):
friendlychipsettext = "Broadcom " + friendlychipsettext
if not (info['fp_version'] is None or info['fp_version'] == 0):
friendlychipsetdescription = friendlychipsetdescription + " (" + _(
"Frontprocessor Version") + ")"
friendlychipsettext = friendlychipsettext + " (" + str(
info['fp_version']) + ")"
info['friendlychipsetdescription'] = friendlychipsetdescription
info['friendlychipsettext'] = friendlychipsettext
info['tuners'] = []
for i in range(0, nimmanager.getSlotCount()):
print "[OpenWebif] -D- tuner '%d' '%s' '%s'" % (
i, nimmanager.getNimName(i), nimmanager.getNim(i).getSlotName())
info['tuners'].append({
"name":
nimmanager.getNim(i).getSlotName(),
"type":
nimmanager.getNimName(i) + " (" +
nimmanager.getNim(i).getFriendlyType() + ")",
"rec":
"",
"live":
""
})
info['ifaces'] = []
ifaces = iNetwork.getConfiguredAdapters()
for iface in ifaces:
info['ifaces'].append({
"name":
iNetwork.getAdapterName(iface),
"friendlynic":
getFriendlyNICChipSet(iface),
"linkspeed":
getLinkSpeed(iface),
"mac":
iNetwork.getAdapterAttribute(iface, "mac"),
"dhcp":
iNetwork.getAdapterAttribute(iface, "dhcp"),
"ipv4method":
getIPv4Method(iface),
"ip":
formatIp(iNetwork.getAdapterAttribute(iface, "ip")),
"mask":
formatIp(iNetwork.getAdapterAttribute(iface, "netmask")),
"v4prefix":
sum([
bin(int(x)).count('1') for x in formatIp(
iNetwork.getAdapterAttribute(iface, "netmask")).split('.')
]),
"gw":
formatIp(iNetwork.getAdapterAttribute(iface, "gateway")),
"ipv6":
getAdapterIPv6(iface)['addr'],
"ipmethod":
getIPMethod(iface),
"firstpublic":
getAdapterIPv6(iface)['firstpublic']
})
info['hdd'] = []
for hdd in harddiskmanager.hdd:
dev = hdd.findMount()
if dev:
stat = os.statvfs(dev)
free = stat.f_bavail * stat.f_frsize / 1048576.
else:
free = -1
if free <= 1024:
free = "%i %s" % (free, _("MB"))
else:
free = free / 1024.
free = "%.1f %s" % (free, _("GB"))
size = hdd.diskSize() * 1000000 / 1048576.
if size > 1048576:
size = "%.1f %s" % ((size / 1048576.), _("TB"))
elif size > 1024:
size = "%.1f %s" % ((size / 1024.), _("GB"))
else:
size = "%d %s" % (size, _("MB"))
iecsize = hdd.diskSize()
# Harddisks > 1000 decimal Gigabytes are labelled in TB
if iecsize > 1000000:
iecsize = (iecsize + 50000) // float(100000) / 10
# Omit decimal fraction if it is 0
if (iecsize % 1 > 0):
iecsize = "%.1f %s" % (iecsize, _("TB"))
else:
iecsize = "%d %s" % (iecsize, _("TB"))
# Round harddisk sizes beyond ~300GB to full tens: 320, 500, 640, 750GB
elif iecsize > 300000:
iecsize = "%d %s" % (((iecsize + 5000) // 10000 * 10), _("GB"))
# ... be more precise for media < ~300GB (Sticks, SSDs, CF, MMC, ...): 1, 2, 4, 8, 16 ... 256GB
elif iecsize > 1000:
iecsize = "%d %s" % (((iecsize + 500) // 1000), _("GB"))
else:
iecsize = "%d %s" % (iecsize, _("MB"))
info['hdd'].append({
"model":
hdd.model(),
"capacity":
size,
"labelled_capacity":
iecsize,
"free":
free,
"mount":
dev,
"friendlycapacity":
_("%s free / %s total") % (free, size + ' ("' + iecsize + '")')
})
info['shares'] = []
autofiles = ('/etc/auto.network', '/etc/auto.network_vti')
for autofs in autofiles:
if fileExists(autofs):
method = "autofs"
for line in file(autofs).readlines():
if not line.startswith('#'):
# Replace escaped spaces that can appear inside credentials with underscores
# Not elegant but we wouldn't want to expose credentials on the OWIF anyways
tmpline = line.replace("\ ", "_")
tmp = tmpline.split()
if not len(tmp) == 3:
continue
name = tmp[0].strip()
type = "unknown"
if "cifs" in tmp[1]:
# Linux still defaults to SMBv1
type = "SMBv1.0"
settings = tmp[1].split(",")
for setting in settings:
if setting.startswith("vers="):
type = setting.replace("vers=", "SMBv")
elif "nfs" in tmp[1]:
type = "NFS"
# Default is r/w
mode = _("r/w")
settings = tmp[1].split(",")
for setting in settings:
if setting == "ro":
mode = _("r/o")
uri = tmp[2]
parts = []
parts = tmp[2].split(':')
if parts[0] is "":
server = uri.split('/')[2]
uri = uri.strip()[1:]
else:
server = parts[0]
ipaddress = None
if server:
# Will fail on literal IPs
try:
# Try IPv6 first, as will Linux
if has_ipv6:
tmpaddress = None
tmpaddress = getaddrinfo(server, 0, AF_INET6)
if tmpaddress:
ipaddress = "[" + list(
tmpaddress)[0][4][0] + "]"
# Use IPv4 if IPv6 fails or is not present
if ipaddress is None:
tmpaddress = None
tmpaddress = getaddrinfo(server, 0, AF_INET)
if tmpaddress:
ipaddress = list(tmpaddress)[0][4][0]
except:
pass
friendlyaddress = server
if ipaddress is not None and not ipaddress == server:
friendlyaddress = server + " (" + ipaddress + ")"
info['shares'].append({
"name": name,
"method": method,
"type": type,
"mode": mode,
"path": uri,
"host": server,
"ipaddress": ipaddress,
"friendlyaddress": friendlyaddress
})
# TODO: fstab
info['transcoding'] = False
#: models transcoding feature
if fileExists("/proc/stb/encoder/0/bitrate"):
if os.path.exists(
eEnv.resolve(
'${libdir}/enigma2/python/Plugins/SystemPlugins/TransCodingSetup/plugin.pyo'
)
) or os.path.exists(
eEnv.resolve(
'${libdir}/enigma2/python/Plugins/SystemPlugins/TranscodingSetup/plugin.pyo'
)
) or os.path.exists(
eEnv.resolve(
'${libdir}/enigma2/python/Plugins/SystemPlugins/MultiTransCodingSetup/plugin.pyo'
)):
info['transcoding'] = True
info['kinopoisk'] = False
lang = ['ru', 'uk', 'lv', 'lt', 'et']
current_language = language.getLanguage()
for l in lang:
if l in current_language:
info['kinopoisk'] = True
break
info['EX'] = ''
if session:
try:
recs = NavigationInstance.instance.getRecordings()
if recs:
# only one stream and only TV
from Plugins.Extensions.OpenWebif.controllers.stream import streamList
s_name = ''
s_cip = ''
print "[OpenWebif] -D- streamList count '%d'" % len(streamList)
if len(streamList) == 1:
from Screens.ChannelSelection import service_types_tv
from enigma import eEPGCache
epgcache = eEPGCache.getInstance()
serviceHandler = eServiceCenter.getInstance()
services = serviceHandler.list(
eServiceReference('%s ORDER BY name' %
(service_types_tv)))
channels = services and services.getContent("SN", True)
s = streamList[0]
srefs = s.ref.toString()
for channel in channels:
if srefs == channel[0]:
s_name = channel[1] + ' (' + s.clientIP + ')'
break
print "[OpenWebif] -D- s_name '%s'" % s_name
for stream in streamList:
srefs = stream.ref.toString()
print "[OpenWebif] -D- srefs '%s'" % srefs
sname = ''
timers = []
for timer in NavigationInstance.instance.RecordTimer.timer_list:
if timer.isRunning() and not timer.justplay:
timers.append(
timer.service_ref.getServiceName().replace(
'\xc2\x86', '').replace('\xc2\x87', ''))
print "[OpenWebif] -D- timer '%s'" % timer.service_ref.getServiceName(
)
# only one recording
if len(timers) == 1:
sname = timers[0]
if sname == '' and s_name != '':
sname = s_name
print "[OpenWebif] -D- recs count '%d'" % len(recs)
for rec in recs:
feinfo = rec.frontendInfo()
frontendData = feinfo and feinfo.getAll(True)
if frontendData is not None:
cur_info = feinfo.getTransponderData(True)
if cur_info:
nr = frontendData['tuner_number']
info['tuners'][nr]['rec'] = getOrbitalText(
cur_info) + ' / ' + sname
service = session.nav.getCurrentService()
if service is not None:
sname = service.info().getName()
feinfo = service.frontendInfo()
frontendData = feinfo and feinfo.getAll(True)
if frontendData is not None:
cur_info = feinfo.getTransponderData(True)
if cur_info:
nr = frontendData['tuner_number']
info['tuners'][nr]['live'] = getOrbitalText(
cur_info) + ' / ' + sname
except Exception, error:
info['EX'] = error
def getTimers(session):
rt = session.nav.RecordTimer
timers = []
for timer in rt.timer_list + rt.processed_timers:
if hasattr(timer, "wakeup_t"):
energytimer = timer.wakeup_t or timer.standby_t or timer.shutdown_t or timer.fnc_t != "off" or 0
if energytimer:
continue
descriptionextended = "N/A"
filename = None
nextactivation = None
if timer.eit and timer.service_ref:
event = eEPGCache.getInstance().lookupEvent(['EX', (str(timer.service_ref), 2, timer.eit)])
if event and event[0][0]:
descriptionextended = event[0][0]
try:
filename = timer.Filename
except Exception:
pass
try:
nextactivation = timer.next_activation
except Exception:
pass
disabled = 0
if timer.disabled:
disabled = 1
justplay = 0
if timer.justplay:
justplay = 1
if hasattr(timer, "allow_duplicate"):
allow_duplicate = timer.allow_duplicate and 1 or 0
else:
allow_duplicate = 1
autoadjust = -1
if hasattr(timer, "autoadjust"):
autoadjust = timer.autoadjust and 1 or 0
elif hasattr(config.recording, "adjust_time_to_event"):
autoadjust = config.recording.adjust_time_to_event.value and 1 or 0
if timer.dirname:
dirname = timer.dirname
else:
dirname = "None"
dontSave = 0
if timer.dontSave:
dontSave = 1
toggledisabled = 1
if timer.disabled:
toggledisabled = 0
toggledisabledimg = "off"
if timer.disabled:
toggledisabledimg = "on"
asrefs = ""
achannels = GetWithAlternative(str(timer.service_ref), False)
if achannels:
asrefs = achannels
vpsplugin_enabled = False
vpsplugin_overwrite = False
vpsplugin_time = -1
if hasattr(timer, "vpsplugin_enabled"):
vpsplugin_enabled = True if timer.vpsplugin_enabled else False
if hasattr(timer, "vpsplugin_overwrite"):
vpsplugin_overwrite = True if timer.vpsplugin_overwrite else False
if hasattr(timer, "vpsplugin_time"):
vpsplugin_time = timer.vpsplugin_time
if not vpsplugin_time:
vpsplugin_time = -1
always_zap = -1
if hasattr(timer, "always_zap"):
if timer.always_zap:
always_zap = 1
else:
always_zap = 0
pipzap = -1
if hasattr(timer, "pipzap"):
if timer.pipzap:
pipzap = 1
else:
pipzap = 0
isAutoTimer = -1
if hasattr(timer, "isAutoTimer"):
if timer.isAutoTimer:
isAutoTimer = 1
else:
isAutoTimer = 0
if six.PY2:
descriptionextended = six.text_type(descriptionextended, 'utf_8', errors='ignore').encode('utf_8', 'ignore')
timers.append({
"serviceref": str(timer.service_ref),
"servicename": removeBad(timer.service_ref.getServiceName()),
"eit": timer.eit,
"name": timer.name,
"description": timer.description,
"descriptionextended": descriptionextended,
"disabled": disabled,
"begin": timer.begin,
"end": timer.end,
"duration": timer.end - timer.begin,
"startprepare": timer.start_prepare,
"justplay": justplay,
"afterevent": timer.afterEvent,
"dirname": dirname,
"tags": " ".join(timer.tags),
"logentries": timer.log_entries,
"backoff": timer.backoff,
"firsttryprepare": timer.first_try_prepare,
"state": timer.state,
"repeated": timer.repeated,
"dontsave": dontSave,
"cancelled": timer.cancelled,
"toggledisabled": toggledisabled,
"toggledisabledimg": toggledisabledimg,
"filename": filename,
"nextactivation": nextactivation,
"realbegin": strftime("%d.%m.%Y %H:%M", (localtime(float(timer.begin)))),
"realend": strftime("%d.%m.%Y %H:%M", (localtime(float(timer.end)))),
"asrefs": asrefs,
"vpsplugin_enabled": vpsplugin_enabled,
"vpsplugin_overwrite": vpsplugin_overwrite,
"vpsplugin_time": vpsplugin_time,
"always_zap": always_zap,
"pipzap": pipzap,
"isAutoTimer": isAutoTimer,
"allow_duplicate": allow_duplicate,
"autoadjust": autoadjust
})
return {
"result": True,
"timers": timers
}
def loadEpg():
epgcache = eEPGCache.getInstance()
epgcache.load()
return {"result": True, "message": ""}
def doBackup(self):
self.save_shutdownOK = config.usage.shutdownOK.value
config.usage.shutdownOK.setValue(True)
config.usage.shutdownOK.save()
configfile.save()
try:
if config.plugins.softwaremanager.epgcache.value:
eEPGCache.getInstance().save()
except:
pass
try:
if pathexists(self.backuppath) == False:
makedirs(self.backuppath)
InitConfig()
self.backupdirs = " ".join(
f.strip("/") for f in
config.plugins.configurationbackup.backupdirs_default.value)
for f in config.plugins.configurationbackup.backupdirs.value:
if not f.strip("/") in self.backupdirs:
self.backupdirs += " " + f.strip("/")
if not "tmp/installed-list.txt" in self.backupdirs:
self.backupdirs += " tmp/installed-list.txt"
if not "tmp/changed-configfiles.txt" in self.backupdirs:
self.backupdirs += " tmp/changed-configfiles.txt"
if not "tmp/passwd.txt" in self.backupdirs:
self.backupdirs += " tmp/passwd.txt"
if not "tmp/groups.txt" in self.backupdirs:
self.backupdirs += " tmp/groups.txt"
ShellCompatibleFunctions.backupUserDB()
pkgs = ShellCompatibleFunctions.listpkg(type="user")
installed = open("/tmp/installed-list.txt", "w")
installed.write('\n'.join(pkgs))
installed.close()
cmd2 = "opkg list-changed-conffiles > /tmp/changed-configfiles.txt"
cmd3 = "tar -C / -czvf " + self.fullbackupfilename
for f in config.plugins.configurationbackup.backupdirs_exclude.value:
cmd3 = cmd3 + " --exclude " + f.strip("/")
for f in BLACKLISTED:
cmd3 = cmd3 + " --exclude " + f.strip("/")
cmd3 = cmd3 + " " + self.backupdirs
cmd = [cmd2, cmd3]
if pathexists(self.fullbackupfilename):
dt = str(
date.fromtimestamp(stat(self.fullbackupfilename).st_ctime))
self.newfilename = self.backuppath + "/" + dt + '-' + self.backupfile
if pathexists(self.newfilename):
remove(self.newfilename)
rename(self.fullbackupfilename, self.newfilename)
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
Console,
title=_("Backup is running..."),
cmdlist=cmd,
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True)
else:
self.session.open(Console,
title=_("Backup is running..."),
cmdlist=cmd,
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True)
except OSError:
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."
),
MessageBox.TYPE_INFO,
timeout=10)
else:
self.session.openWithCallback(
self.backupErrorCB,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."
),
MessageBox.TYPE_INFO,
timeout=10)
def __init__(self):
Renderer.__init__(self)
VariableText.__init__(self)
self.epgcache = eEPGCache.getInstance()
def getTimers(session):
rt = session.nav.RecordTimer
timers = []
for timer in rt.timer_list + rt.processed_timers:
descriptionextended = "N/A"
filename = None
nextactivation = None
if timer.eit and timer.service_ref:
event = eEPGCache.getInstance().lookupEvent(['EX', (str(timer.service_ref), 2, timer.eit)])
if event and event[0][0]:
descriptionextended = event[0][0]
try:
filename = timer.Filename
except Exception:
pass
try:
nextactivation = timer.next_activation
except Exception:
pass
disabled = 0
if timer.disabled:
disabled = 1
justplay = 0
if timer.justplay:
justplay = 1
if timer.dirname:
dirname = timer.dirname
else:
dirname = "None"
dontSave = 0
if timer.dontSave:
dontSave = 1
toggledisabled = 1
if timer.disabled:
toggledisabled = 0
toggledisabledimg = "off"
if timer.disabled:
toggledisabledimg = "on"
asrefs = ""
achannels = GetWithAlternative(str(timer.service_ref), False)
if achannels:
asrefs = achannels
vpsplugin_enabled = False
vpsplugin_overwrite = False
vpsplugin_time = -1
if hasattr(timer, "vpsplugin_enabled"):
vpsplugin_enabled = True if timer.vpsplugin_enabled else False
if hasattr(timer, "vpsplugin_overwrite"):
vpsplugin_overwrite = True if timer.vpsplugin_overwrite else False
if hasattr(timer, "vpsplugin_time"):
vpsplugin_time = timer.vpsplugin_time
if not vpsplugin_time:
vpsplugin_time = -1
always_zap = -1
if hasattr(timer, "always_zap"):
if timer.always_zap:
always_zap = 1
else:
always_zap = 0
timers.append({
"serviceref": str(timer.service_ref),
"servicename": timer.service_ref.getServiceName().replace('\xc2\x86', '').replace('\xc2\x87', ''),
"eit": timer.eit,
"name": timer.name,
"description": timer.description,
"descriptionextended": unicode(descriptionextended, 'utf_8', errors='ignore').encode('utf_8', 'ignore'),
"disabled": disabled,
"begin": timer.begin,
"end": timer.end,
"duration": timer.end - timer.begin,
"startprepare": timer.start_prepare,
"justplay": justplay,
"afterevent": timer.afterEvent,
"dirname": dirname,
"tags": " ".join(timer.tags),
"logentries": timer.log_entries,
"backoff": timer.backoff,
"firsttryprepare": timer.first_try_prepare,
"state": timer.state,
"repeated": timer.repeated,
"dontsave": dontSave,
"cancelled": timer.cancelled,
"toggledisabled": toggledisabled,
"toggledisabledimg": toggledisabledimg,
"filename": filename,
"nextactivation": nextactivation,
"realbegin": strftime("%d.%m.%Y %H:%M", (localtime(float(timer.begin)))),
"realend": strftime("%d.%m.%Y %H:%M", (localtime(float(timer.end)))),
"asrefs": asrefs,
"vpsplugin_enabled": vpsplugin_enabled,
"vpsplugin_overwrite": vpsplugin_overwrite,
"vpsplugin_time": vpsplugin_time,
"always_zap": always_zap
})
return {
"result": True,
"timers": timers
}
def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
self.days = (_("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"),
_("Sat"), _("Sun"))
self.timer = timer
self.onSelChanged = []
if selChangedCB is not None:
self.onSelChanged.append(selChangedCB)
GUIComponent.__init__(self)
self.type = type
self.l = eListboxPythonMultiContent()
self.eventItemFont = gFont("Regular", applySkinFactor(22))
self.eventTimeFont = gFont("Regular", applySkinFactor(16))
self.iconSize = applySkinFactor(21)
self.iconDistance = applySkinFactor(2)
self.colGap = applySkinFactor(10)
self.skinColumns = False
self.tw = applySkinFactor(90)
self.dy = 0
if type == EPG_TYPE_SINGLE:
self.l.setBuildFunc(self.buildSingleEntry)
elif type == EPG_TYPE_MULTI:
self.l.setBuildFunc(self.buildMultiEntry)
else:
assert (type == EPG_TYPE_SIMILAR)
self.l.setBuildFunc(self.buildSimilarEntry)
self.epgcache = eEPGCache.getInstance()
self.clocks = [
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/epgclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/epgclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/epgclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/epgclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/epgclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zapclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zapclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zapclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zapclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zapclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zaprecclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zaprecclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zaprecclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zaprecclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/zaprecclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repepgclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repepgclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repepgclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repepgclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repepgclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzapclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzapclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzapclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzapclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzapclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzaprecclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzaprecclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzaprecclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_CURRENT_SKIN,
'icons/repzaprecclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/repzaprecclock_post.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/pipclock_add.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/pipclock_pre.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/pipclock.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/pipclock_prepost.png')),
LoadPixmap(cached=True,
path=resolveFilename(SCOPE_CURRENT_SKIN,
'icons/pipclock_post.png'))
]
def EpgHistorySecondsChanged(configElement): eEPGCache.getInstance().setEpgHistorySeconds(config.epg.histminutes.value*60)
def getEpisode(self, timer, block=False):
log.info("timername, service, begin, end:", timer.name,
str(timer.service_ref.ref), timer.begin, timer.end)
if hasattr(timer, 'sp_in_queue'):
if timer.sp_in_queue:
msg = _("Skipping timer because it is already in queue")
log.warning(msg, timer.name)
timer.log(601, "[SeriesPlugin]" + " " + msg)
return
# We have to compare the length,
# because of the E2 special chars handling for creating the filenames
#if timer.name == name:
# Mad Men != Mad_Men
if TAG in timer.tags:
msg = _("Skipping timer because it is already handled"
) + "\n\n" + _("Can be configured within the setup")
log.info(msg, timer.name)
timer.log(607, "[SeriesPlugin]" + " " + msg)
return
if timer.begin < time() + 60:
msg = _("Skipping timer because it starts in less than 60 seconds")
log.debug(msg, timer.name)
timer.log(604, "[SeriesPlugin]" + " " + msg)
return
if timer.isRunning():
msg = _("Skipping timer because it is already running")
log.debug(msg, timer.name)
timer.log(605, "[SeriesPlugin]" + " " + msg)
return
if timer.justplay:
msg = _("Skipping timer because it is a just play timer")
log.debug(msg, timer.name)
timer.log(606, "[SeriesPlugin]" + " " + msg)
return
event = None
epgcache = eEPGCache.getInstance()
if timer.eit:
event = epgcache.lookupEventId(timer.service_ref.ref, timer.eit)
log.debug("lookupEventId", timer.eit, event)
if not (event):
event = epgcache.lookupEventTime(
timer.service_ref.ref,
timer.begin + ((timer.end - timer.begin) / 2))
log.debug("lookupEventTime", event)
if event:
if not (len(timer.name) == len(event.getEventName())):
msg = _("Skipping timer because it is already modified %s" %
(timer.name))
log.info(msg)
timer.log(602, "[SeriesPlugin]" + " " + msg)
return
begin = event.getBeginTime() or 0
duration = event.getDuration() or 0
end = begin + duration
else:
if config.plugins.seriesplugin.timer_eit_check.value:
msg = _("Skipping timer because no event was found")
log.info(msg, timer.name)
timer.log(603, "[SeriesPlugin]" + " " + msg)
return
else:
# We don't know the exact margins, we will assume the E2 default margins
log.debug(
"We don't know the exact margins, we will assume the E2 default margins"
)
begin = timer.begin + (config.recording.margin_before.value *
60)
end = timer.end - (config.recording.margin_after.value * 60)
timer.log(
600, "[SeriesPlugin]" + " " + _("Try to find infos for %s" %
(timer.name)))
seriesPlugin = getInstance()
if timer.service_ref:
log.debug("getEpisode:", timer.name, timer.begin, timer.end, block)
timer.sp_in_queue = True
return seriesPlugin.getEpisode(boundFunction(
self.timerCallback, timer),
timer.name,
begin,
end,
timer.service_ref,
future=True,
block=block)
else:
msg = _("Skipping lookup because no channel is specified")
log.warning(msg)
self.timerCallback(timer, msg)
return None
def JobEpgCacheSave(self):
print '[EPGC] Saving EPGCache.'
from enigma import eEPGCache
epgcache = eEPGCache.getInstance()
epgcache.save()
def __init__(self, session):
self.session = session
Screen.__init__(self, session)
#bouquets = getBouquetList();
self.waitForEpgWorker = 0
self.setup_title = _("Advanced matching")
self.setTitle(self.setup_title)
from Screens.InfoBar import InfoBar
self.infoBarInstance = InfoBar.instance
self.epgcache = eEPGCache.getInstance()
self.offerToSave = False
self.callback = None
#cfg = EPGConfig.loadUserSettings()
# load all working bouquets
#filter = cfg["sources"]
#self.bouquets = []
self.channels = []
#for x in bouquets:
# if x[0]in filter or filter is None:
# self.bouquets.append(x[0])
# (description, value, index, selected)
#self.bouquets.append(SelectionEntryComponent(x[0], x[1], 0, False))
self["statusbar"] = Label()
self["status"] = Label()
self["text"] = Label()
self["text2"] = Label()
self["list1"] = ColoredList()
self["list2"] = ColoredList()
self.desktopSize = getDesktop(0).size()
#self["videoPicture"] = VideoWindow(decoder = 0, fb_width = 445, fb_height = 263)
self["videoPicture"] = VideoWindow(decoder=0,
fb_width=self.desktopSize.width(),
fb_height=self.desktopSize.height())
self.curFocus = 1
self["actions"] = NumberActionMap(
[
"DirectionActions", "EPGSelectActions", "NumberActions",
"OkCancelActions", "ColorActions", "TimerEditActions"
], {
"cancel": self.cancel,
"red": self.epgLoadCall,
"green": self.doSave,
"blue": self.install,
"nextService": self.right,
"prevService": self.left,
"ok": self.zap,
"up": self.up,
"down": self.down,
"left": self.pageUp,
"right": self.pageDown,
"1": self.keyed,
"2": self.keyed,
"3": self.keyed,
"4": self.keyed,
"5": self.keyed,
"6": self.keyed
}, -2)
self["key_red"] = Label(_("Load epg packages"))
self["key_refresh"] = Label(_("Refresh matches"))
self["key_filter"] = Label(_("Filter channels"))
self["key_green"] = Label(_("Save"))
self["key_blue"] = Label(_("Install"))
#self["key_green"] = Label(_("Find matches"))
#self["key_yellow"] = Label(_("Find matches"))
self.channelMode = 1 # initiate on all channels
self.updateTimer = enigma.eTimer()
self.updateTimer.callback.append(self.updateStatus)
self.updateStatus()
self.updateTimer.start(2000)
# load all unmapped channels
if not epgWorker.active and len(epgWorker.channels) == 0:
#self.doFilterCallback(True)
self.doChannelLoad()
self.waitForEpgWorker = 1
elif epgWorker.active:
self.waitForEpgWorker = 1
self.onLayoutFinish.append(self.onLoad)
def setEPGCacheTimespan(configElement):
eEPGCache.getInstance().setCacheTimespan(int(configElement.value))
def keyGo(self, result=None):
if not self.timerentry_service_ref.isRecordable():
self.session.openWithCallback(
self.selectChannelSelector, MessageBox,
_("You didn't select a channel to record from."),
MessageBox.TYPE_ERROR)
return
self.timer.name = self.timerentry_name.value
self.timer.description = self.timerentry_description.value
self.timer.justplay = self.timerentry_justplay.value == "zap"
self.timer.always_zap = self.timerentry_justplay.value == "zap+record"
self.timer.zap_wakeup = self.timerentry_zapwakeup.value
self.timer.rename_repeat = self.timerentry_renamerepeat.value
self.timer.conflict_detection = self.timerentry_conflictdetection.value
if self.timerentry_justplay.value == "zap":
if not self.timerentry_showendtime.value:
self.timerentry_endtime.value = self.timerentry_starttime.value
self.timerentry_afterevent.value = "nothing"
self.timer.resetRepeated()
self.timer.afterEvent = {
"nothing": AFTEREVENT.NONE,
"deepstandby": AFTEREVENT.DEEPSTANDBY,
"standby": AFTEREVENT.STANDBY,
"auto": AFTEREVENT.AUTO
}[self.timerentry_afterevent.value]
self.timer.descramble = {
"normal": True,
"descrambled+ecm": True,
"scrambled+ecm": False,
}[self.timerentry_recordingtype.value]
self.timer.record_ecm = {
"normal": False,
"descrambled+ecm": True,
"scrambled+ecm": True,
}[self.timerentry_recordingtype.value]
self.timer.service_ref = self.timerentry_service_ref
self.timer.tags = self.timerentry_tags
if self.timer.dirname or self.timerentry_dirname.value != defaultMoviePath(
):
self.timer.dirname = self.timerentry_dirname.value
config.movielist.last_timer_videodir.value = self.timer.dirname
config.movielist.last_timer_videodir.save()
if self.timerentry_type.value == "once":
self.timer.begin, self.timer.end = self.getBeginEnd()
if self.timerentry_type.value == "repeated":
if self.timerentry_repeated.value == "daily":
for x in (0, 1, 2, 3, 4, 5, 6):
self.timer.setRepeated(x)
if self.timerentry_repeated.value == "weekly":
self.timer.setRepeated(self.timerentry_weekday.index)
if self.timerentry_repeated.value == "weekdays":
for x in (0, 1, 2, 3, 4):
self.timer.setRepeated(x)
if self.timerentry_repeated.value == "user":
for x in (0, 1, 2, 3, 4, 5, 6):
if self.timerentry_day[x].value:
self.timer.setRepeated(x)
self.timer.repeatedbegindate = self.getTimestamp(
self.timerentry_repeatedbegindate.value,
self.timerentry_starttime.value)
if self.timer.repeated:
self.timer.begin = self.getTimestamp(
self.timerentry_repeatedbegindate.value,
self.timerentry_starttime.value)
self.timer.end = self.getTimestamp(
self.timerentry_repeatedbegindate.value,
self.timerentry_endtime.value)
else:
self.timer.begin = self.getTimestamp(
time(), self.timerentry_starttime.value)
self.timer.end = self.getTimestamp(
time(), self.timerentry_endtime.value)
# when a timer end is set before the start, add 1 day
if self.timer.end < self.timer.begin:
self.timer.end += 86400
if self.timer.eit is not None:
event = eEPGCache.getInstance().lookupEventId(
self.timer.service_ref.ref, self.timer.eit)
if event:
n = event.getNumOfLinkageServices()
if n > 1:
tlist = []
ref = self.session.nav.getCurrentlyPlayingServiceOrGroup()
parent = self.timer.service_ref.ref
selection = 0
for x in range(n):
i = event.getLinkageService(parent, x)
if i.toString() == ref.toString():
selection = x
tlist.append((i.getName(), i))
self.session.openWithCallback(
self.subserviceSelected,
ChoiceBox,
title=_("Please select a subservice to record..."),
list=tlist,
selection=selection)
return
elif n > 0:
parent = self.timer.service_ref.ref
self.timer.service_ref = ServiceReference(
event.getLinkageService(parent, 0))
self.saveTimer()
self.close((True, self.timer))
def setOutdatedEPGTimespan(configElement):
eEPGCache.getInstance().setOutdatedEPGTimespan(configElement.value)
def editTimer(self, param):
print "[WebComponents.Timer] editTimer"
#OK first we need to parse all of your Parameters
#For some of them (like afterEvent or justplay) we can use default values
#for others (the serviceReference or the Begin/End time of the timer
#we have to quit if they are not set/have illegal values
if 'sRef' not in param:
return (False, _("Missing Parameter: sRef"))
service_ref = ServiceReference(param['sRef'])
repeated = int(param.get('repeated') or 0)
if 'begin' not in param:
return (False, _("Missing Parameter: begin"))
begin = int(float(param['begin']))
if 'end' not in param:
return (False, _("Missing Parameter: end"))
end = int(float(param['end']))
tm = int(time())
if tm <= begin:
pass
elif tm > begin and tm < end and repeated == 0:
pass
elif repeated == 0:
return (False, _("Illegal Parameter value for Parameter begin : '%s'") % begin)
if 'applyMargin' in param:
if param['applyMargin'] == "1":
begin -= config.recording.margin_before.value * 60
end += config.recording.margin_after.value * 60
if 'name' not in param:
return (False, _("Missing Parameter: name"))
name = param['name']
if 'description' not in param:
return (False, _("Missing Parameter: description"))
description = param['description'].replace("\n", " ")
eit = param.get("eit", None)
if eit is None or eit.strip() == "":
eit = 0
else:
try:
eit = int(eit)
except ValueError:
return (False, _("Illegal Parameter value for Parameter eit : '%s'") % eit)
print "[WebComponents.Sources.Timer]: eit=%d" % eit
if eit != 0:
#check if the given event exists, if it doesn't the timer may be already running
epgcache = eEPGCache.getInstance()
event = epgcache.lookupEventId(eServiceReference(param['sRef']), eit)
if event:
eit = event.getEventId()
#TODO add some subservice handling
else:
print "[WebComponents.Sources.Timer] event not found, will be ignored"
disabled = False #Default to: Enabled
if 'disabled' in param:
if param['disabled'] == "1":
disabled = True
else:
#TODO - maybe we can give the user some useful hint here
pass
justplay = False #Default to: Record
if 'justplay' in param:
if param['justplay'] == "1":
justplay = True
afterEvent = 3 #Default to Afterevent: Auto
if 'afterevent' in param:
if (param['afterevent'] == "0") or (param['afterevent'] == "1") or (param['afterevent'] == "2"):
afterEvent = int(param['afterevent'])
dirname = preferredTimerPath()
if 'dirname' in param and param['dirname']:
dirname = param['dirname']
tags = []
if 'tags' in param and param['tags']:
tags = unescape(param['tags']).split(' ')
delold = 0
if 'deleteOldOnSave' in param:
delold = int(param['deleteOldOnSave'])
#Try to edit an existing Timer
if delold:
if 'channelOld' in param and param['channelOld']:
channelOld = ServiceReference(param['channelOld'])
else:
return (False, _("Missing Parameter: channelOld"))
# We do need all of the following Parameters, too, for being able of finding the Timer.
# Therefore so we can neither use default values in this part nor can we
# continue if a parameter is missing
if 'beginOld' not in param:
return (False, _("Missing Parameter: beginOld"))
beginOld = int(param['beginOld'])
if 'endOld' not in param:
return (False, _("Missing Parameter: endOld"))
endOld = int(param['endOld'])
#let's try to find the timer
try:
for timer in self.recordtimer.timer_list + self.recordtimer.processed_timers:
if str(timer.service_ref) == str(channelOld):
if int(timer.begin) == beginOld:
if int(timer.end) == endOld: #we've found the timer we've been searching for
#set the new data
timer.service_ref = service_ref
timer.begin = begin
timer.end = end
timer.name = name
timer.description = description
timer.eit = eit
timer.disabled = disabled
timer.justplay = justplay
timer.afterEvent = afterEvent
timer.dirname = dirname
timer.tags = tags
timer.repeated = repeated
timer.processRepeated()
#sanity check
timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, timer)
conflicts = None
if not timersanitycheck.check():
conflicts = timersanitycheck.getSimulTimerList()
if conflicts is not None:
for x in conflicts:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
if not timersanitycheck.check():
conflicts = timersanitycheck.getSimulTimerList()
if conflicts is None:
self.recordtimer.timeChanged(timer) #go and save it
print "[WebComponents.Timer] editTimer: Timer changed!"
return (True, "Timer '%s' changed" % (timer.name))
else:
print "[WebComponents.Timer] editTimer conflicting Timers: %s" % (conflicts)
msg = ""
for t in conflicts:
msg = "%s / %s" % (msg, t.name)
return (False, _("Conflicting Timer(s) detected! %s") % (msg))
except Exception as e:
#obviously some value was not good, return an error
import traceback
print traceback.format_exc()
return (False, _("Changing the timer for '%s' failed!") % name)
return (False, _("Could not find timer '%s' with given start and end time!") % name)
#Try adding a new Timer
try:
#Create a new instance of recordtimerentry
timer = RecordTimerEntry(service_ref, begin, end, name, description, eit, disabled, justplay, afterEvent, dirname=dirname, tags=tags)
timer.repeated = repeated
#add the new timer
conflicts = self.recordtimer.record(timer)
if conflicts is None:
return (True, _("Timer '%s' added") % (timer.name))
else:
print "[WebComponents.Timer] editTimer conflicting Timers: %s" % (conflicts)
msg = ""
for timer in conflicts:
msg = "%s / %s" % (msg, timer.name)
return (False, _("Conflicting Timer(s) detected! %s") % (msg))
except Exception, e:
#something went wrong, most possibly one of the given paramater-values was wrong
print "[WebComponents.Timer] editTimer exception: %s" % (e)
return (False, _("Could not add timer '%s'!") % name)
def setEPGCachePath(configElement):
eEPGCache.getInstance().setCacheFile(configElement.value)
def doBackup(self):
configfile.save()
try:
if config.plugins.softwaremanager.epgcache.value:
eEPGCache.getInstance().save()
except:
pass
try:
if path.exists(self.backuppath) == False:
makedirs(self.backuppath)
try:
self.backupdirs = ' '.join(config.plugins.configurationbackup.
backupdirs_default.value)
except:
InitConfig()
self.backupdirs = ' '.join(config.plugins.configurationbackup.
backupdirs_default.value)
for f in config.plugins.configurationbackup.backupdirs.value:
if not f in self.backupdirs:
self.backupdirs = self.backupdirs + " " + f
if not "/tmp/installed-list.txt" in self.backupdirs:
self.backupdirs = self.backupdirs + " /tmp/installed-list.txt"
if not "/tmp/changed-configfiles.txt" in self.backupdirs:
self.backupdirs = self.backupdirs + " /tmp/changed-configfiles.txt"
cmd1 = "opkg list-installed | egrep -v '^ ' | awk '{print $1 }' | egrep 'enigma2-plugin-|task-base|packagegroup-base|^ca-certificates$|^joe$|^mc$|^nano$|^openvpn|^easy-rsa$|^simple-rsa$|^perl|^streamproxy$|^wget$' > /tmp/installed-list.txt"
cmd2 = "opkg list-changed-conffiles > /tmp/changed-configfiles.txt"
cmd3 = "tar -czvf " + self.fullbackupfilename + " " + self.backupdirs
for f in config.plugins.configurationbackup.backupdirs_exclude.value:
cmd3 = cmd3 + " --exclude " + f.strip("/")
cmd3 = cmd3 + " --exclude home/root/.cache"
cmd = [cmd1, cmd2, cmd3]
if path.exists(self.fullbackupfilename):
dt = str(
date.fromtimestamp(stat(self.fullbackupfilename).st_ctime))
self.newfilename = self.backuppath + "/" + dt + '-' + self.backupfile
if path.exists(self.newfilename):
remove(self.newfilename)
rename(self.fullbackupfilename, self.newfilename)
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
Console,
title=_("Backup is running..."),
cmdlist=cmd,
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True)
else:
self.session.open(Console,
title=_("Backup is running..."),
cmdlist=cmd,
finishedCallback=self.backupFinishedCB,
closeOnSuccess=True)
except OSError:
if self.finished_cb:
self.session.openWithCallback(
self.finished_cb,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."
),
MessageBox.TYPE_INFO,
timeout=10)
else:
self.session.openWithCallback(
self.backupErrorCB,
MessageBox,
_("Sorry, your backup destination is not writeable.\nPlease select a different one."
),
MessageBox.TYPE_INFO,
timeout=10)
def isInTimer(self, eventid, begin, duration, service):
time_match = 0
chktime = None
chktimecmp = None
chktimecmp_end = None
end = begin + duration
refstr = str(service)
for x in self.timer_list:
check = x.service_ref.ref.toString() == refstr
if not check:
sref = x.service_ref.ref
parent_sid = sref.getUnsignedData(5)
parent_tsid = sref.getUnsignedData(6)
if parent_sid and parent_tsid: # check for subservice
sid = sref.getUnsignedData(1)
tsid = sref.getUnsignedData(2)
sref.setUnsignedData(1, parent_sid)
sref.setUnsignedData(2, parent_tsid)
sref.setUnsignedData(5, 0)
sref.setUnsignedData(6, 0)
check = sref.toCompareString() == refstr
num = 0
if check:
check = False
event = eEPGCache.getInstance().lookupEventId(
sref, eventid)
num = event and event.getNumOfLinkageServices() or 0
sref.setUnsignedData(1, sid)
sref.setUnsignedData(2, tsid)
sref.setUnsignedData(5, parent_sid)
sref.setUnsignedData(6, parent_tsid)
for cnt in range(num):
subservice = event.getLinkageService(sref, cnt)
if sref.toCompareString(
) == subservice.toCompareString():
check = True
break
if check:
if x.repeated != 0:
if chktime is None:
chktime = localtime(begin)
chktimecmp = chktime.tm_wday * 1440 + chktime.tm_hour * 60 + chktime.tm_min
chktimecmp_end = chktimecmp + (duration / 60)
time = localtime(x.begin)
for y in (0, 1, 2, 3, 4, 5, 6):
if x.repeated & (1 << y) and (x.begin <= begin or
begin <= x.begin <= end):
timecmp = y * 1440 + time.tm_hour * 60 + time.tm_min
if timecmp <= chktimecmp < (timecmp + (
(x.end - x.begin) / 60)):
time_match = ((timecmp + (
(x.end - x.begin) / 60)) - chktimecmp) * 60
elif chktimecmp <= timecmp < chktimecmp_end:
time_match = (chktimecmp_end - timecmp) * 60
else: #if x.eit is None:
if begin <= x.begin <= end:
diff = end - x.begin
if time_match < diff:
time_match = diff
elif x.begin <= begin <= x.end:
diff = x.end - begin
if time_match < diff:
time_match = diff
if time_match:
break
return time_match
def isInTimer(self, eventid, begin, duration, service):
returnValue = None
type = 0
time_match = 0
isAutoTimer = False
bt = None
check_offset_time = not config.recording.margin_before.value and not config.recording.margin_after.value
end = begin + duration
refstr = ':'.join(service.split(':')[:11])
for x in self.timer_list:
if x.isAutoTimer == 1:
isAutoTimer = True
else:
isAutoTimer = False
check = ':'.join(x.service_ref.ref.toString().split(':')[:11]) == refstr
if not check:
sref = x.service_ref.ref
parent_sid = sref.getUnsignedData(5)
parent_tsid = sref.getUnsignedData(6)
if parent_sid and parent_tsid:
# check for subservice
sid = sref.getUnsignedData(1)
tsid = sref.getUnsignedData(2)
sref.setUnsignedData(1, parent_sid)
sref.setUnsignedData(2, parent_tsid)
sref.setUnsignedData(5, 0)
sref.setUnsignedData(6, 0)
check = sref.toCompareString() == refstr
num = 0
if check:
check = False
event = eEPGCache.getInstance().lookupEventId(sref, eventid)
num = event and event.getNumOfLinkageServices() or 0
sref.setUnsignedData(1, sid)
sref.setUnsignedData(2, tsid)
sref.setUnsignedData(5, parent_sid)
sref.setUnsignedData(6, parent_tsid)
for cnt in range(num):
subservice = event.getLinkageService(sref, cnt)
if sref.toCompareString() == subservice.toCompareString():
check = True
break
if check:
timer_end = x.end
timer_begin = x.begin
type_offset = 0
if not x.repeated and check_offset_time:
if 0 < end - timer_end <= 59:
timer_end = end
elif 0 < timer_begin - begin <= 59:
timer_begin = begin
if x.justplay:
type_offset = 5
if (timer_end - x.begin) <= 1:
timer_end += 60
if x.always_zap:
type_offset = 10
timer_repeat = x.repeated
# if set 'don't stop current event but disable coming events' for repeat timer
running_only_curevent = x.disabled and x.isRunning() and timer_repeat
if running_only_curevent:
timer_repeat = 0
type_offset += 15
if timer_repeat != 0:
type_offset += 15
if bt is None:
bt = localtime(begin)
bday = bt.tm_wday
begin2 = 1440 + bt.tm_hour * 60 + bt.tm_min
end2 = begin2 + duration / 60
xbt = localtime(x.begin)
xet = localtime(timer_end)
offset_day = False
checking_time = x.begin < begin or begin <= x.begin <= end
if xbt.tm_yday != xet.tm_yday:
oday = bday - 1
if oday == -1: oday = 6
offset_day = x.repeated & (1 << oday)
xbegin = 1440 + xbt.tm_hour * 60 + xbt.tm_min
xend = xbegin + ((timer_end - x.begin) / 60)
if xend < xbegin:
xend += 1440
if x.repeated & (1 << bday) and checking_time:
if begin2 < xbegin <= end2:
if xend < end2:
# recording within event
time_match = (xend - xbegin) * 60
type = type_offset + 3
else:
# recording last part of event
time_match = (end2 - xbegin) * 60
type = type_offset + 1
elif xbegin <= begin2 <= xend:
if xend < end2:
# recording first part of event
time_match = (xend - begin2) * 60
type = type_offset + 4
else:
# recording whole event
time_match = (end2 - begin2) * 60
type = type_offset + 2
elif offset_day:
xbegin -= 1440
xend -= 1440
if begin2 < xbegin <= end2:
if xend < end2:
# recording within event
time_match = (xend - xbegin) * 60
type = type_offset + 3
else:
# recording last part of event
time_match = (end2 - xbegin) * 60
type = type_offset + 1
elif xbegin <= begin2 <= xend:
if xend < end2:
# recording first part of event
time_match = (xend - begin2) * 60
type = type_offset + 4
else:
# recording whole event
time_match = (end2 - begin2) * 60
type = type_offset + 2
elif offset_day and checking_time:
xbegin -= 1440
xend -= 1440
if begin2 < xbegin <= end2:
if xend < end2:
# recording within event
time_match = (xend - xbegin) * 60
type = type_offset + 3
else:
# recording last part of event
time_match = (end2 - xbegin) * 60
type = type_offset + 1
elif xbegin <= begin2 <= xend:
if xend < end2:
# recording first part of event
time_match = (xend - begin2) * 60
type = type_offset + 4
else:
# recording whole event
time_match = (end2 - begin2) * 60
type = type_offset + 2
else:
if begin < timer_begin <= end:
if timer_end < end:
# recording within event
time_match = timer_end - timer_begin
type = type_offset + 3
else:
# recording last part of event
time_match = end - timer_begin
type = type_offset + 1
elif timer_begin <= begin <= timer_end:
if timer_end < end:
# recording first part of event
time_match = timer_end - begin
type = type_offset + 4
else:
# recording whole event
time_match = end - begin
type = type_offset + 2
if time_match:
if type in (2,7,12,17,22,27):
# When full recording do not look further
returnValue = (time_match, [type], isAutoTimer)
break
elif returnValue:
if type not in returnValue[1]:
returnValue[1].append(type)
else:
returnValue = (time_match, [type])
return returnValue
def tryPrepare(self):
if self.justplay:
return True
else:
if not self.calculateFilename():
self.do_backoff()
self.start_prepare = time() + self.backoff
return False
rec_ref = self.service_ref and self.service_ref.ref
if rec_ref and rec_ref.flags & eServiceReference.isGroup:
rec_ref = getBestPlayableServiceReference(rec_ref, eServiceReference())
if not rec_ref:
self.log(1, "'get best playable service for group... record' failed")
return False
self.setRecordingPreferredTuner()
self.record_service = rec_ref and NavigationInstance.instance.recordService(rec_ref)
if not self.record_service:
self.log(1, "'record service' failed")
self.setRecordingPreferredTuner(setdefault=True)
return False
name = self.name
description = self.description
if self.repeated:
epgcache = eEPGCache.getInstance()
queryTime=self.begin+(self.end-self.begin)/2
evt = epgcache.lookupEventTime(rec_ref, queryTime)
if evt:
if self.rename_repeat:
event_description = evt.getShortDescription()
if not event_description:
event_description = evt.getExtendedDescription()
if event_description and event_description != description:
description = event_description
event_name = evt.getEventName()
if event_name and event_name != name:
name = event_name
if not self.calculateFilename(event_name):
self.do_backoff()
self.start_prepare = time() + self.backoff
return False
event_id = evt.getEventId()
else:
event_id = -1
else:
event_id = self.eit
if event_id is None:
event_id = -1
prep_res=self.record_service.prepare(self.Filename + self.record_service.getFilenameExtension(), self.begin, self.end, event_id, name.replace("\n", ""), description.replace("\n", ""), ' '.join(self.tags), bool(self.descramble), bool(self.record_ecm))
if prep_res:
if prep_res == -255:
self.log(4, "failed to write meta information")
else:
self.log(2, "'prepare' failed: error %d" % prep_res)
# we must calc nur start time before stopRecordService call because in Screens/Standby.py TryQuitMainloop tries to get
# the next start time in evEnd event handler...
self.do_backoff()
self.start_prepare = time() + self.backoff
NavigationInstance.instance.stopRecordService(self.record_service)
self.record_service = None
self.setRecordingPreferredTuner(setdefault=True)
return False
return True
def JobEpgCacheLoad(self):
print '[EPGC] Refreshing EPGCache.'
from enigma import eEPGCache
epgcache = eEPGCache.getInstance()
epgcache.load()
def EpgHistorySecondsChanged(configElement):
from enigma import eEPGCache
eEPGCache.getInstance().setEpgHistorySeconds(
config.epg.histminutes.getValue() * 60)
def parseEPG(self, simulateOnly=False, uniqueId=None, callback=None):
from plugin import AUTOTIMER_VERSION
doLog("AutoTimer Version: " + AUTOTIMER_VERSION)
if NavigationInstance.instance is None:
doLog("[AutoTimer] Navigation is not available, can't parse EPG")
return (0, 0, 0, [], [], [])
new = 0
modified = 0
timers = []
conflicting = []
similars = []
skipped = []
# Init new added timers list
global addNewTimers
addNewTimers = []
if config.plugins.autotimer.searchlog_write.value and not simulateOnly:
self.prepareSearchLogfile()
if currentThread().getName() == 'MainThread':
doBlockingCallFromMainThread = lambda f, *a, **kw: f(*a, **kw)
else:
doBlockingCallFromMainThread = blockingCallFromMainThread
# NOTE: the config option specifies "the next X days" which means today (== 1) + X
delta = timedelta(days=config.plugins.autotimer.maxdaysinfuture.value + 1)
evtLimit = mktime((date.today() + delta).timetuple())
checkEvtLimit = delta.days > 1
del delta
# Read AutoTimer configuration
self.readXml()
# Get E2 instances
epgcache = eEPGCache.getInstance()
serviceHandler = eServiceCenter.getInstance()
recordHandler = NavigationInstance.instance.RecordTimer
# Save Timer in a dict to speed things up a little
# We include processed timers as we might search for duplicate descriptions
# NOTE: It is also possible to use RecordTimer isInTimer(), but we won't get the timer itself on a match
timerdict = defaultdict(list)
doBlockingCallFromMainThread(self.populateTimerdict, epgcache, recordHandler, timerdict, simulateOnly=simulateOnly)
# Create dict of all movies in all folders used by an autotimer to compare with recordings
# The moviedict will be filled only if one AutoTimer is configured to avoid duplicate description for any recordings
moviedict = defaultdict(list)
# Iterate Timer
for timer in self.getEnabledTimerList():
if uniqueId is None or timer.id == uniqueId:
doLog("[AutoTimer] Start search for %s" % (timer.match.replace('\xc2\x86', '').replace('\xc2\x87', '')))
tup = doBlockingCallFromMainThread(self.parseTimer, timer, epgcache, serviceHandler, recordHandler, checkEvtLimit, evtLimit, timers, conflicting, similars, skipped, timerdict, moviedict, simulateOnly=simulateOnly)
if callback:
callback(timers, conflicting, similars, skipped)
del timers[:]
del conflicting[:]
del similars[:]
del skipped[:]
else:
new += tup[0]
modified += tup[1]
if not simulateOnly:
if sp_showResult is not None:
blockingCallFromMainThread(sp_showResult)
if config.plugins.autotimer.remove_double_and_conflicts_timers.value != "no":
self.reloadTimerList(recordHandler)
return (len(timers), new, modified, timers, conflicting, similars)
def program_dataAvail(self, str):
if self.timer is None or self.timer.state == TimerEntry.StateEnded or self.timer.cancelled:
self.program_abort()
self.stop_simulation()
return
if self.timer.vpsplugin_enabled == False or config.plugins.vps.enabled.value == False:
if self.activated_auto_increase:
self.timer.autoincrease = False
self.program_abort()
self.stop_simulation()
return
lines = str.split("\n")
for line in lines:
data = line.split()
if len(data) == 0:
continue
self.timer.log(0, "[VPS] " + line)
if data[0] == "RUNNING_STATUS":
if data[1] == "0": # undefined
if data[2] == "FOLLOWING":
data[1] = "1"
else:
data[1] = "4"
if data[1] == "1": # not running
# Wenn der Eintrag im Following (Section_Number = 1) ist,
# dann nicht beenden (Sendung begann noch gar nicht)
if data[2] == "FOLLOWING":
self.activate_autoincrease()
elif self.timer.state == TimerEntry.StateRunning and not self.pausing and not self.set_next_event(
):
self.stop_recording()
self.dont_restart_program = True
self.program_abort()
elif data[1] == "2": # starts in a few seconds
self.activate_autoincrease()
if self.timer.state == TimerEntry.StateWaiting:
self.session.nav.RecordTimer.doActivate(self.timer)
elif data[1] == "3": # pausing
self.pausing = True
if self.timer.state == TimerEntry.StateRunning:
self.activate_autoincrease()
elif data[1] == "4": # running
self.pausing = False
if self.timer.state == TimerEntry.StateRunning:
self.activate_autoincrease()
elif self.timer.state == TimerEntry.StateWaiting or self.timer.state == TimerEntry.StatePrepared:
# setze Startzeit auf jetzt
self.timer.begin = int(time())
self.session.nav.RecordTimer.timeChanged(self.timer)
self.activate_autoincrease()
self.program_abort()
self.stop_simulation()
vps_timers.checksoon(2000) # Programm neu starten
elif data[1] == "5": # service off-air
self.timer.vpsplugin_overwrite = False
if self.activated_auto_increase:
self.timer.autoincrease = False
self.activated_auto_increase = False
elif data[0] == "EVENT_ENDED":
if not self.set_next_event():
if self.timer.state == TimerEntry.StateRunning:
self.stop_recording()
# program terminates by itself
#self.program_abort()
self.stop_simulation()
elif data[0] == "OTHER_TS_RUNNING_STATUS":
if self.timer.state == TimerEntry.StateWaiting:
self.timer.start_prepare = int(time())
self.session.nav.RecordTimer.doActivate(self.timer)
# program terminates by itself
#self.program_abort()
self.stop_simulation()
vps_timers.checksoon(2000)
# PDC
elif data[0] == "PDC_FOUND_EVENT_ID":
self.found_pdc = True
self.timer.eit = int(data[1])
epgcache = eEPGCache.getInstance()
evt = epgcache.lookupEventId(self.rec_ref, self.timer.eit)
if evt:
self.timer.name = evt.getEventName()
self.timer.description = evt.getShortDescription()
# program terminates by itself
#self.program_abort()
vps_timers.checksoon(500)
elif data[0] == "FOUND_EVENT_ON_SCHEDULE":
starttime = int(data[1])
duration = int(data[2])
# Soll die Sendung laut EPG erst nach dem Ende dieses Timers beginnen?
if (not self.timer.vpsplugin_overwrite and
(self.timer.end + 300) < starttime) or (
self.timer.vpsplugin_overwrite and
(self.timer.end + self.max_extending_timer - 1800) <
starttime):
if self.new_timer_copy is None:
if self.activated_auto_increase:
self.timer.autoincrease = False
self.activated_auto_increase = False
self.copyTimer(starttime, duration)
self.timer.log(
0,
"[VPS] copied this timer, since the event may start later than this timer ends"
)
elif not self.activated_auto_increase:
self.activate_autoincrease()
elif data[0] == "EVENT_OVER" or data[0] == "CANNOT_FIND_EVENT":
self.max_extending_timer = 2 * 3600
if self.activated_auto_increase:
self.timer.autoincrease = False
self.activated_auto_increase = False
elif data[0] == "PDC_MULTIPLE_FOUND_EVENT":
self.check_and_add_event(int(data[1]))
# Programm meldet, dass die EIT (present/following) des Senders offenbar
# momentan fehlerhaft ist
elif data[0] == "EIT_APPARENTLY_UNRELIABLE":
if self.timer.vpsplugin_overwrite:
self.timer.vpsplugin_overwrite = False
self.timer.log(
0, "[VPS] can't trust EPG currently, go to safe mode")
tmdb_api = "3c3efcf47c3577558812bb9d64019d65" if config.plugins.xtraEvent.tvdbAPI.value != "": tvdb_api = config.plugins.xtraEvent.tvdbAPI.value else: tvdb_api = "a99d487bb3426e5f3a60dea6d3d3c7ef" if config.plugins.xtraEvent.fanartAPI.value != "": fanart_api = config.plugins.xtraEvent.fanartAPI.value else: fanart_api = "6d231536dea4318a88cb2520ce89473b" if config.plugins.xtraEvent.omdbAPI.value != "": omdb_api = config.plugins.xtraEvent.omdbAPI.value else: omdb_apis = ["6a4c9432", "a8834925", "550a7c40", "8ec53e6b"] omdb_api = random.choice(omdb_apis) epgcache = eEPGCache.getInstance() pathLoc = config.plugins.xtraEvent.loc.value + "xtraEvent/" desktop_size = getDesktop(0).size().width() class downloads(Screen): def __init__(self, session): Screen.__init__(self, session) self.session = session skin = None if desktop_size <= 1280: if config.plugins.xtraEvent.skinSelect.value == "default": skin = "/usr/lib/enigma2/python/Plugins/Extensions/xtraEvent/skins/downloads_720_default.xml" elif config.plugins.xtraEvent.skinSelect.value == "skin_2": skin = "/usr/lib/enigma2/python/Plugins/Extensions/xtraEvent/skins/downloads_720_2.xml" elif config.plugins.xtraEvent.skinSelect.value == "skin_3": skin = "/usr/lib/enigma2/python/Plugins/Extensions/xtraEvent/skins/downloads_720_3.xml"
def getSingleEventList(ref):
epgcache = eEPGCache.getInstance()
test = ['RIBDTEX', (str(ref), 0, time(), -1)]
event = epgcache.lookupEvent(test)
return event
