def fetchlog(logtype):
releasenotes = ""
try:
# TODO: fix url for obh
if getImageType() == 'release':
sourceurl = 'http://www.vuplus-community.net/feeds/%s/%s/%s/%s-git.log' % (getImageDistro(), getImageType(), getImageVersion(), logtype)
else:
sourceurl = 'http://www.vuplus-community.net/feeds/%s/%s/%s/%s-git.log' % (getImageDistro(), getImageType(), getImageVersion(), logtype)
print "[GitLog]",sourceurl
sourcefile,headers = urllib.urlretrieve(sourceurl)
fd = open(sourcefile, 'r')
for line in fd.readlines():
if getImageType() == 'release' and line.startswith('openvix: developer'):
print '[GitLog] Skipping dev line'
continue
elif getImageType() == 'developer' and line.startswith('openvix: release'):
print '[GitLog] Skipping release line'
continue
releasenotes += line
fd.close()
releasenotes = releasenotes.replace('\nopenvix: build',"\n\nopenvix: build")
releasenotes = releasenotes.replace('\nopenvix: %s' % getImageType(),"\n\nopenvix: %s" % getImageType())
except:
releasenotes = '404 Not Found'
return releasenotes
def __init__(self, session, pcallback = None, noosd = False):
self.session = session
if (getDesktop(0).size().width() < 800):
skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__)
self.isHD = 0
else:
skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__)
self.isHD = 1
f = open(skin, "r")
self.skin = f.read()
f.close()
Screen.__init__(self, session)
Screen.setTitle(self, _("CrossEPG"))
self["background"] = Pixmap()
self["action"] = Label(_("Defragmentation..."))
self["summary_action"] = StaticText(_("Defragmentation..."))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress"].hide()
self["actions"] = NumberActionMap(["WizardActions", "InputActions"],
{
"back": self.quit
}, -1)
self.status = 0
self.retValue = True
self.config = CrossEPG_Config()
self.config.load()
self.lamedb = self.config.lamedb
if getImageDistro() != "ViX" and getImageDistro() != "AAF" and getImageDistro() != "openMips" and getImageDistro() != "Atemio":
self.db_root = self.config.db_root
else:
self.db_root = config.misc.epgcachepath.value + 'crossepg'
if not pathExists(self.db_root):
if not createDir(self.db_root):
self.db_root = "/hdd/crossepg"
self.pcallback = pcallback
self.wrapper = CrossEPG_Wrapper()
self.wrapper.addCallback(self.wrapperCallback)
self.hideprogress = eTimer()
self.hideprogress.callback.append(self["progress"].hide)
self.pcallbacktimer = eTimer()
self.pcallbacktimer.callback.append(self.doCallback)
if noosd:
self.wrappertimer = eTimer()
self.wrappertimer.callback.append(self.startWrapper)
self.wrappertimer.start(100, 1)
else:
self.onFirstExecBegin.append(self.firstExec)
def startMenu(menuid):
if getImageDistro() in ('openatv'):
if menuid != "extended":
return []
elif getImageDistro() in ('openhdf'):
if menuid != "devices_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("Temperature and fan control"), main, "tempfancontrol", 80)]
def menu(menuid):
if getImageDistro() in ('openmips'):
if menuid != "ui_menu":
return [ ]
elif getImageDistro() in ('openhdf'):
if menuid != "gui_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("NameZAP Setup"), main, "namezap_setup", None)]
def gete2distroversion(self): try: from boxbranding import getImageDistro if getImageDistro() == "openatv": return "openatv" elif getImageDistro() == "teamblue": return "teamblue" elif getImageDistro() == "VTi": return "VTi" except ImportError: return "VTi"
def startSetup(menuid):
if getImageDistro() in ('openmips'):
if menuid != "video_menu":
return [ ]
elif getImageDistro() in ('openhdf'):
if menuid != "video_menu":
return [ ]
else:
if menuid != "system":
return [ ]
return [(_("Autoresolution"), autoresSetup, "autores_setup", 45)]
def makeList(self):
self.list = []
if getImageDistro() != "openvix":
device_default = None
i = 0
for mountpoint in self.mountpoint:
if mountpoint == self.config.db_root:
device_default = self.mountdescription[i]
i += 1
## default device is really important... if miss a default we force it on first entry and update now the main config
if device_default == None:
self.config.db_root = self.mountpoint[0]
device_default = self.mountdescription[0]
lamedb_default = _("main lamedb")
if self.config.lamedb != "lamedb":
lamedb_default = self.config.lamedb.replace("lamedb.", "").replace(".", " ")
scheduled_default = None
if self.config.download_standby_enabled:
scheduled_default = _("every hour (only in standby)")
elif self.config.download_daily_enabled:
scheduled_default = _("once a day")
else:
scheduled_default = _("disabled")
if getImageDistro() != "openvix":
self.list.append((_("Storage device"), ConfigSelection(self.mountdescription, device_default)))
if len(self.lamedbs_desc) > 1:
self.list.append((_("Preferred lamedb"), ConfigSelection(self.lamedbs_desc, lamedb_default)))
self.list.append((_("Enable csv import"), ConfigYesNo(self.config.csv_import_enabled > 0)))
if getImageDistro() != "openvix":
self.list.append((_("Force epg reload on boot"), ConfigYesNo(self.config.force_load_on_boot > 0)))
self.list.append((_("Scheduled download"), ConfigSelection(self.automatictype, scheduled_default)))
if self.config.download_daily_enabled:
ttime = localtime()
ltime = (ttime[0], ttime[1], ttime[2], self.config.download_daily_hours, self.config.download_daily_minutes, ttime[5], ttime[6], ttime[7], ttime[8])
self.list.append((_("Scheduled download at"), ConfigClock(mktime(ltime))))
if not self.fastpatch:
self.list.append((_("Reboot after a scheduled download"), ConfigYesNo(self.config.download_daily_reboot > 0)))
self.list.append((_("Reboot after a manual download"), ConfigYesNo(self.config.download_manual_reboot > 0)))
self.list.append((_("Show as plugin"), ConfigYesNo(self.config.show_plugin > 0)))
self.list.append((_("Show as extension"), ConfigYesNo(self.config.show_extension > 0)))
if getImageDistro() != "openvix":
self.list.append((_("Show 'Force reload' as plugin"), ConfigYesNo(self.config.show_force_reload_as_plugin > 0)))
self["config"].list = self.list
self["config"].setList(self.list)
self.setInfo()
def startSetup(menuid):
if getImageDistro() in ('openmips'):
if menuid != "general_menu":
return [ ]
elif getImageDistro() in ('openhdf'):
if menuid != "record_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("VPS Settings"), setup, "vps", 50)]
def main(menuid):
if getImageDistro() in ('teamblue', ):
if menuid != "general_menu":
return [ ]
elif getImageDistro() in ('openhdf', ):
if menuid != "gui_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("Permanent Clock"), startConfig, "permanent_clock", None)]
def setInfo(self):
index = self["config"].getCurrentIndex()
if getImageDistro() == "openvix":
index += 1
if index == 0:
self["information"].setText(_("Drive where you save data.\nThe drive MUST be mounted in rw. If you can't see your device here probably is mounted as read only or autofs handle it only in read only mode. In case of mount it manually and try again"))
return
if len(self.lamedbs_desc) <= 1:
index += 1
if index == 1:
self["information"].setText(_("Lamedb used for epg.dat conversion.\nThis option doesn't work with crossepg patch v2"))
return
if index == 2:
self["information"].setText(_("Import *.csv and *.bin from %s/import or %s/import\n(*.bin are binaries with a csv as stdout)") % (self.config.db_root, self.config.home_directory))
return
if getImageDistro() == "openvix":
index += 1
if index == 3:
self["information"].setText(_("Reload epg at every boot.\nNormally it's not necessary but recover epg after an enigma2 crash"))
return
if index == 4:
if self.config.download_standby_enabled:
self["information"].setText(_("When the decoder is in standby opentv providers will be automatically downloaded every hour.\nXMLTV providers will be always downloaded only once a day"))
return
elif self.config.download_daily_enabled:
self["information"].setText(_("Download epg once a day"))
return
else:
self["information"].setText(_("Scheduled download disabled"))
return
if self.config.download_daily_enabled == 0:
index += 1
if index == 5:
if self.config.download_standby_enabled or self.config.download_daily_enabled:
self["information"].setText(_("Time for scheduled daily download"))
return
if self.fastpatch:
index += 2
if index == 6:
self["information"].setText(_("Automatically reboot the decoder after a scheduled download"))
return
if index == 7:
self["information"].setText(_("Automatically reboot the decoder after a manual download"))
return
if index == 8:
self["information"].setText(_("Show crossepg in plugin menu"))
return
if index == 9:
self["information"].setText(_("Show crossepg in extensions menu"))
return
if index == 10:
self["information"].setText(_("Show crossepg force load in plugin menu"))
return
def Plugins(**kwargs):
if getImageDistro() in ("openatv"):
list = [
PluginDescriptor(
where = PluginDescriptor.WHERE_SESSIONSTART,
fnc = GBIpboxClientAutostart
),
PluginDescriptor(
name = "IPBOX Client",
description = _("IPBox network client"),
where = PluginDescriptor.WHERE_MENU,
needsRestart = False,
fnc = ipboxclientStart
)
]
else:
list = [
PluginDescriptor(
where = PluginDescriptor.WHERE_SESSIONSTART,
fnc = GBIpboxClientAutostart
),
PluginDescriptor(
name = "GBIpboxClient",
description = _("Gigablue IPBox network client"),
where = [PluginDescriptor.WHERE_EXTENSIONSMENU, PluginDescriptor.WHERE_PLUGINMENU],
fnc = GBIpboxClient
),
PluginDescriptor(
name = "GBIpboxClient",
description = _("Gigablue IPBox network client"),
where = PluginDescriptor.WHERE_MENU,
needsRestart = False,
fnc = ipboxclientStart
)
]
if config.ipboxclient.remotetimers.value:
list.append(PluginDescriptor(
where = PluginDescriptor.WHERE_RECORDTIMER,
fnc = ipboxclientRecordTimer
))
if not config.ipboxclient.firstconf.value and not getImageDistro() in ("openatv"):
list.append(PluginDescriptor(
name = _("IPBox wizard"),
where = PluginDescriptor.WHERE_WIZARD,
needsRestart = False,
fnc=(30, GBIpboxWizard)
))
return list
def __init__(self, session, timerinstance):
self.session = session
self.list = []
self.timerinstance = timerinstance
self.remotetimer_old = config.ipboxclient.remotetimers.value
Screen.__init__(self, session)
ConfigListScreen.__init__(self, self.list)
if getImageDistro() in ("openatv"):
self.setTitle(_('IPBOX Client'))
else:
self.setTitle(_('GBIpbox Client'))
self["VKeyIcon"] = Boolean(False)
self["text"] = StaticText(_('NOTE: the remote HDD feature require samba installed on server box.'))
self["key_red"] = Button(_('Cancel'))
self["key_green"] = Button(_('Save'))
self["key_yellow"] = Button(_('Scan'))
self["key_blue"] = Button(_('About'))
self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
{
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keySave,
"yellow": self.keyScan,
"blue": self.keyAbout
}, -2)
self.populateMenu()
if not config.ipboxclient.firstconf.value:
self.timer = eTimer()
self.timer.callback.append(self.scanAsk)
self.timer.start(100)
def startSetup(menuid, **kwargs):
if getImageDistro() == "ventonsupport":
if menuid == "expert":
return [(_("Audio Sync Setup"), setup, "audiosync_setup", 41)]
else:
return []
elif getImageDistro() in ("openatv", "openhdf"):
if menuid == "audio_menu":
return [(_("Audio Sync Setup"), setup, "audiosync_setup", 41)]
else:
return []
else:
if menuid == "system":
return [(_("Audio Sync Setup"), setup, "audiosync_setup", 41)]
else:
return []
def startCmd(self, cmd, args = None):
if cmd == self.CMD_UPDATE:
for fn in os.listdir('/var/lib/opkg'):
if fn.startswith(getImageDistro()):
os.remove('/var/lib/opkg/'+fn)
self.runCmdEx("update")
elif cmd == self.CMD_UPGRADE:
append = ""
if args["test_only"]:
append = " -test"
self.runCmdEx("upgrade" + append)
elif cmd == self.CMD_LIST:
self.fetchedList = []
if args['installed_only']:
self.runCmdEx("list_installed")
else:
self.runCmd("list")
elif cmd == self.CMD_INSTALL:
self.runCmd("install " + args['package'])
elif cmd == self.CMD_REMOVE:
self.runCmd("remove " + args['package'])
elif cmd == self.CMD_UPGRADE_LIST:
self.fetchedList = []
self.runCmdEx("list-upgradable")
self.setCurrentCommand(cmd)
def startCmd(self, cmd, args = None):
if cmd == self.CMD_UPDATE:
for fn in os.listdir('/var/lib/opkg'):
if fn.startswith(getImageDistro()):
os.remove('/var/lib/opkg/' + fn)
self.runCmdEx('update')
elif cmd == self.CMD_UPGRADE:
append = ''
if args['test_only']:
append = ' -test'
if len(self.excludeList) > 0:
for x in self.excludeList:
print "[IPKG] exclude Package (hold): '%s'" % x[0]
os.system('opkg flag hold ' + x[0])
self.runCmdEx('upgrade' + append)
elif cmd == self.CMD_LIST:
self.fetchedList = []
self.excludeList = []
if args['installed_only']:
self.runCmdEx('list_installed')
else:
self.runCmd('list')
elif cmd == self.CMD_INSTALL:
self.runCmd('--force-overwrite install ' + args['package'])
elif cmd == self.CMD_REMOVE:
self.runCmd('remove ' + args['package'])
elif cmd == self.CMD_UPGRADE_LIST:
self.fetchedList = []
self.excludeList = []
self.runCmd('list-upgradable')
self.setCurrentCommand(cmd)
def menu_main(menuid, **kwargs):
if getImageDistro() in ("openvix", "openatv", "openspa", "openhdf"):
if menuid != "epg":
return []
else:
return []
return [(_("EPGRefresh"), main, "epgrefresh", None)]
def timermenu(menuid):
if menuid == "timermenu":
if getImageDistro() in ('openhdf'):
return [(_("Auto Timer"), main, "autotimer_setup", None)]
else:
return [(_("AutoTimers"), main, "autotimer_setup", None)]
return []
def startCmd(self, cmd, args = None):
if cmd == self.CMD_UPDATE:
if getImageVersion() == '4.0':
if os.path.exists('/var/lib/opkg/lists'):
rmtree('/var/lib/opkg/lists')
else:
for fn in os.listdir('/var/lib/opkg'):
if fn.startswith(getImageDistro()):
os.remove('/var/lib/opkg/'+fn)
self.runCmdEx("update")
elif cmd == self.CMD_UPGRADE:
append = ""
if args["test_only"]:
append = " -test"
if len(self.excludeList) > 0:
for x in self.excludeList:
print"[IPKG] exclude Package (hold): '%s'" % x[0]
os.system("opkg flag hold " + x[0])
self.runCmdEx("upgrade" + append)
elif cmd == self.CMD_LIST:
self.fetchedList = []
self.excludeList = []
if args['installed_only']:
self.runCmdEx("list_installed")
else:
self.runCmd("list")
elif cmd == self.CMD_INSTALL:
self.runCmd("--force-overwrite install " + args['package'])
elif cmd == self.CMD_REMOVE:
self.runCmd("remove " + args['package'])
elif cmd == self.CMD_UPGRADE_LIST:
self.fetchedList = []
self.excludeList = []
self.runCmd("list-upgradable")
self.setCurrentCommand(cmd)
def createSetup(self):
list = [ self.cfg_enabled ]
if self.EPG.enabled.value:
list.append(self.cfg_wakeup)
list.append(self.cfg_deepstandby)
if self.EPG.deepstandby.value == "wakeup":
list.append(self.cfg_shutdown)
if not self.EPG.shutdown.value:
list.append(self.cfg_standby_afterwakeup)
list.append(self.cfg_day_profile)
list.append(self.cfg_runboot)
if self.EPG.runboot.value != "4":
list.append(self.cfg_runboot_day)
if self.EPG.runboot.value == "1" or self.EPG.runboot.value == "2":
list.append(self.cfg_runboot_restart)
list.append(self.cfg_showinextensions)
# Only show these settings if not using OpenATV:
if getImageDistro() not in ("openatv"):
list.append(self.cfg_showinplugins)
list.append(self.cfg_showinmainmenu)
list.append(self.cfg_import_onlybouquet)
if hasattr(enigma.eEPGCache, 'flushEPG'):
list.append(self.cfg_clear_oldepg)
list.append(self.cfg_longDescDays)
if fileExists("/usr/lib/enigma2/python/Plugins/Extensions/AutoTimer/plugin.py"):
try:
from Plugins.Extensions.AutoTimer.AutoTimer import AutoTimer
list.append(self.cfg_parse_autotimer)
except:
print>>log, "[XMLTVImport] AutoTimer Plugin not installed"
self["config"].list = list
self["config"].l.setList(list)
def createSetup(self):
self.list = []
self.rcsctype = getConfigListEntry(_("Remote Control System Code"), config.plugins.remotecontrolcode.systemcode)
self.list.append( self.rcsctype )
if getImageDistro() in ("openvix", "openatv"):
self.list.append(getConfigListEntry(_("Text support"), config.misc.remotecontrol_text_support))
self["config"].list = self.list
self["config"].l.setList(self.list)
def settings(menuid, **kwargs):
if getImageDistro() in ('openhdf'):
if menuid != "video_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("3D settings"), opensettings, "3d_settings", 10)]
def showinSetup(menuid):
if getImageDistro() in ('openhdf'):
if menuid != "video_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("Advanced HDMI-Cec Setup"), main, "", 46)]
def startSetup(menuid):
if getImageDistro() in ('teamblue'):
if menuid != "general_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("System cleanup"), setup, "AutomaticCleanup", 50)]
def menu(menuid):
if getImageDistro() in ('teamblue'):
if menuid != "general_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("Hide Plugins"), main, "pluginhider_setup", None)]
def startSetup(menuid):
if getImageDistro() in ('openhdf'):
if menuid != "video_menu":
return [ ]
else:
if menuid != "system":
return []
return [(_("A/V-Color space settings"), pluginOpen, "av_colorspace_setup", 40)]
def selSetup(menuid, **kwargs):
if getImageDistro() in ("openatv"):
if menuid != "extended":
return [ ]
else:
if menuid != "system":
return [ ]
return [(_("Fan Control"), main, "fansetup_config", 70)]
def initWrapper(self): if len(self.providers) == 0: self.closeAndCallback(True) else: if getImageDistro() != "openvix": self.wrapper.init(CrossEPG_Wrapper.CMD_DOWNLOADER, self.config.db_root) else: self.wrapper.init(CrossEPG_Wrapper.CMD_DOWNLOADER, config.misc.epgcachepath.value + 'crossepg')
def startSetup(menuid):
if getImageDistro() in ('openhdf', 'openatv'):
if menuid != "audio_menu":
return [ ]
else:
if menuid != "system": # show setup only in system level menu
return []
return [(_("Automatic Volume Adjustment"), setup, "AutomaticVolumeAdjustment", 46)]
def startChange(menuid):
if getImageDistro() in ('teamblue', ):
if menuid != "general_menu":
return [ ]
else:
if menuid != "system":
return []
return [(title, main, "change_root_passwd", 50)]
def getBackupPath():
backuppath = config.plugins.configurationbackup.backuplocation.getValue()
box = getBoxType()
distro = getImageDistro()
if backuppath.endswith('/'):
return backuppath + 'backup_' + distro + '_' + box
else:
return backuppath + '/backup_' + distro + '_' + box
def Plugins(**kwargs):
if getImageDistro() == "openvix":
return PluginDescriptor(name=_("Tuner Server setup"), description=_("Allow Streaming From Box Tuners"), where = PluginDescriptor.WHERE_MENU, needsRestart = True, fnc=settings)
else:
return PluginDescriptor(name=_("Tuner Server"), description=_("Allow Streaming From Box Tuners"), where = PluginDescriptor.WHERE_PLUGINMENU, needsRestart = False, fnc=main)
from Components.Button import Button
from Components.config import getConfigListEntry, configfile, ConfigSelection, ConfigSubsection, ConfigText, ConfigLocations
from Components.config import config
from Components.ConfigList import ConfigList, ConfigListScreen
from Components.FileList import MultiFileSelectList
from Components.Network import iNetwork
from Plugins.Plugin import PluginDescriptor
from enigma import eTimer, eEnv, eConsoleAppContainer, eEPGCache
from Tools.Directories import *
from os import popen, path, makedirs, listdir, access, stat, rename, remove, W_OK, R_OK
from time import gmtime, strftime, localtime
from datetime import datetime
from boxbranding import getBoxType, getMachineBrand, getMachineName, getImageVersion, getImageDistro
boxtype = getBoxType()
imagename = getImageDistro()
imageversion = getImageVersion()
config.plugins.configurationbackup = ConfigSubsection()
config.plugins.configurationbackup.backuplocation = ConfigText(
default='/media/hdd/', visible_width=50, fixed_size=False)
config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[
eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces',
'/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf',
'/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw',
'/etc/hostname',
eEnv.resolve(
"${datadir}/enigma2/keymap.usr"), '/etc/CCcam.cfg', '/usr/keys/'
])
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'] = getBoxBrand()
info['model'] = getBoxType()
try:
info['procmodel'] = getBoxProc()
except: # noqa: E722
info['procmodel'] = None
try:
info['procmodeltype'] = getBoxProcType()
except: # noqa: E722
info['procmodeltype'] = None
try:
info['lcd'] = getLcd()
except:
info['lcd'] = 0
try:
info['grabpip'] = getGrabPip()
except:
info['grabpip'] = 0
cpu = about.getCPUInfoString()
info['chipset'] = cpu
info['cpubrand'] = about.getCPUBrand()
info['cpuarch'] = about.getCPUArch()
info['flashtype'] = about.getFlashType()
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'])
info['uptime'] = about.getSTBUptime()
info["webifver"] = OPENWEBIFVER
info['imagedistro'] = boxbranding.getImageDistro()
info['friendlyimagedistro'] = getFriendlyImageDistro()
info['oever'] = boxbranding.getImageBuild()
info['pliversion'] = boxbranding.getPliVersion()
info['plirevision'] = boxbranding.getPliRevision()
info['visionmodule'] = about.getVisionModule()
info['enigmaver'] = getEnigmaVersionString()
info['driverdate'] = about.getDriverInstalledDate()
info['kernelver'] = about.getKernelVersionString()
info['dvbapitype'] = about.getDVBAPI()
info['gstreamerversion'] = about.getGStreamerVersionString(cpu)
info['ffmpegversion'] = about.getFFmpegVersionString()
info['pythonversion'] = about.getPythonVersionString()
try:
info['hwserial'] = getHWSerial()
except: # noqa: E722
info['hwserial'] = None
if (info['hwserial'] is None or info['hwserial'] == "unknown"):
info['hwserial'] = about.getCPUSerial()
try:
info['boxrctype'] = getBoxRCType()
except: # noqa: E722
info['boxrctype'] = None
if (info['boxrctype'] is None or info['boxrctype'] == "unknown"):
if fileExists("/usr/bin/remotecfg"):
info['boxrctype'] = _("Amlogic remote")
elif fileExists("/usr/sbin/lircd"):
info['boxrctype'] = _("LIRC remote")
info['transcoding'] = boxbranding.getHaveTranscoding()
info['multitranscoding'] = boxbranding.getHaveMultiTranscoding()
info['displaytype'] = boxbranding.getDisplayType()
info['updatedatestring'] = about.getUpdateDateString()
info['enigmadebuglvl'] = eGetEnigmaDebugLvl()
info['imagearch'] = boxbranding.getImageArch()
info['imagefolder'] = boxbranding.getImageFolder()
info['imagefilesystem'] = boxbranding.getImageFileSystem()
info['feedsurl'] = boxbranding.getFeedsUrl()
info['developername'] = boxbranding.getDeveloperName()
info['builddatestring'] = about.getBuildDateString()
info['imagefpu'] = boxbranding.getImageFPU()
info['havemultilib'] = boxbranding.getHaveMultiLib()
try:
info['fp_version'] = getFPVersion()
except: # noqa: E722
info['fp_version'] = None
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: # noqa: E722
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['EX'] = ''
if session:
try:
# gets all current stream clients for images using eStreamServer
# TODO: merge eStreamServer and streamList
# TODO: get tuner info for streams
# TODO: get recoding/timer info if more than one
info['streams'] = []
try:
streams = []
from enigma import eStreamServer
streamServer = eStreamServer.getInstance()
if streamServer is not None:
for x in streamServer.getConnectedClients():
servicename = ServiceReference(
x[1]).getServiceName() or "(unknown service)"
if int(x[2]) == 0:
strtype = "S"
else:
strtype = "T"
info['streams'].append({
"ref": x[1],
"name": servicename,
"ip": x[0],
"type": strtype
})
except Exception as error:
print("[OpenWebif] -D- no eStreamServer %s" % error)
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)
# only for debug
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())
# TODO: more than 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 as error:
info['EX'] = error
info['timerpipzap'] = False
info['timerautoadjust'] = False
try:
timer = RecordTimerEntry('', 0, 0, '', '', 0)
if hasattr(timer, "pipzap"):
info['timerpipzap'] = True
if hasattr(timer, "autoadjust"):
info['timerautoadjust'] = True
except Exception as error:
print("[OpenWebif] -D- RecordTimerEntry check %s" % error)
STATICBOXINFO = info
return info
def install3(self, yesno):
print("yesno:", yesno)
if yesno:
cmd2 = 'mkdir /media/nfr4xboot;mount ' + self.mysel + ' /media/nfr4xboot'
os.system(cmd2)
if fileExists('/proc/mounts'):
fileExists('/proc/mounts')
f = open('/proc/mounts', 'r')
for line in f.readlines():
if line.find(self.mysel):
mntdev = line.split(' ')[0]
f.close()
mntid = os.system(
'blkid -s UUID -o value ' + mntdev +
'>/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/bin/install'
)
os.system("mv /etc/fstab /etc/fstab1")
os.system(
"grep -v /media/nfr4xboot /etc/fstab1 > /etc/fstab"
)
os.system("rm /etc/fstab1")
os.system(
'blkid -s UUID -o value ' + mntdev +
'>/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/bin/install'
)
fstabuuid = os.popen('blkid -s UUID -o value ' +
mntdev).read()
fstabuuidwrite = 'UUID=' + fstabuuid.strip(
) + ' /media/nfr4xboot auto defaults 1 1'
fileHandle = open('/etc/fstab', 'a')
fileHandle.write(fstabuuidwrite)
fileHandle.close()
cmd = 'mkdir ' + self.mysel + 'NFR4XBootI;mkdir ' + self.mysel + 'NFR4XBootUpload'
os.system(cmd)
os.system('cp /sbin/nfr4x_multiboot /sbin/nfr4xinit')
os.system(
'chmod 777 /sbin/nfr4xinit;chmod 777 /sbin/init;ln -sfn /sbin/nfr4xinit /sbin/init'
)
os.system(
'mv /etc/init.d/volatile-media.sh /etc/init.d/volatile-media.sh.back'
)
out3 = open('/media/nfr4xboot/NFR4XBootI/.timer', 'w')
out3.write(
config.NFRBootmanager.bootmanagertimeout.value)
out3.close()
out2 = open('/media/nfr4xboot/NFR4XBootI/.nfr4xboot',
'w')
out2.write('Flash')
out2.close()
out = open(
'/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/.nfr4xboot_location',
'w')
out.write(self.mysel)
out.close()
os.system(
'cp /usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/.nfr4xboot_location /etc/nfr4x/'
)
image = getImageDistro()
if fileExists('/etc/image-version'):
if 'build' not in image:
f = open('/etc/image-version', 'r')
for line in f.readlines():
if 'build=' in line:
image = image + ' build ' + line[6:-1]
open('/media/nfr4xboot/NFR4XBootI/.Flash',
'w').write(image)
break
f.close()
self.myclose2(_('NFR4XBoot has been installed succesfully!'))
else:
cmd2 = 'mkdir /media/nfr4xboot;mount ' + self.mysel + ' /media/nfr4xboot'
os.system(cmd2)
if fileExists('/proc/mounts'):
fileExists('/proc/mounts')
f = open('/proc/mounts', 'r')
for line in f.readlines():
if line.find(self.mysel):
mntdev = line.split(' ')[0]
f.close()
mntid = os.system(
'blkid -s UUID -o value ' + mntdev +
'>/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/bin/install'
)
os.system("mv /etc/fstab /etc/fstab1")
os.system(
"grep -v /media/nfr4xboot /etc/fstab1 > /etc/fstab"
)
os.system("rm /etc/fstab1")
os.system(
'blkid -s UUID -o value ' + mntdev +
'>/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/bin/install'
)
fstabuuid = os.popen('blkid -s UUID -o value ' +
mntdev).read()
fstabuuidwrite = 'UUID=' + fstabuuid.strip(
) + ' /media/nfr4xboot auto defaults 1 1'
fileHandle = open('/etc/fstab', 'a')
fileHandle.write(fstabuuidwrite)
fileHandle.close()
cmd = 'mkdir ' + self.mysel + 'NFR4XBootI;mkdir ' + self.mysel + 'NFR4XBootUpload'
os.system(cmd)
os.system(
'cp /usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/bin/nfr4xinitnoboot /sbin/nfr4xinit'
)
os.system(
'chmod 777 /sbin/nfr4xinit;chmod 777 /sbin/init;ln -sfn /sbin/nfr4xinit /sbin/init'
)
os.system(
'mv /etc/init.d/volatile-media.sh /etc/init.d/volatile-media.sh.back'
)
out2 = open('/media/nfr4xboot/NFR4XBootI/.nfr4xboot',
'w')
out2.write('Flash')
out2.close()
out = open(
'/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/.nfr4xboot_location',
'w')
out.write(self.mysel)
out.close()
os.system(
'cp /usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot/.nfr4xboot_location /etc/nfr4x/'
)
image = getImageDistro()
if fileExists('/etc/image-version'):
if 'build' not in image:
f = open('/etc/image-version', 'r')
for line in f.readlines():
if 'build=' in line:
image = image + ' build ' + line[6:-1]
open('/media/nfr4xboot/NFR4XBootI/.Flash',
'w').write(image)
break
f.close()
self.myclose2(
_('NFR4XBoot has been installed succesfully, and Box rebooting now!'
))
from Components.SystemInfo import SystemInfo
from Components.Label import Label
from Components.ActionMap import ActionMap
from Components.About import about
from Components import Harddisk
from Components.ChoiceList import ChoiceList, ChoiceEntryComponent
from Screens.Console import Console
from Screens.ChoiceBox import ChoiceBox
from Screens.MessageBox import MessageBox
from time import time, strftime, localtime
from Tools.BoundFunction import boundFunction
from Tools.Multiboot import GetImagelist, GetCurrentImage, GetCurrentImageMode, GetCurrentKern, GetCurrentRoot, GetBoxName
import os, commands, datetime
from boxbranding import getMachineBrand, getMachineName, getDriverDate, getImageVersion, getImageBuild, getBrandOEM, getMachineBuild, getImageFolder, getMachineUBINIZE, getMachineMKUBIFS, getMachineMtdKernel, getMachineMtdRoot, getMachineKernelFile, getMachineRootFile, getImageFileSystem, getImageDistro, getImageVersion
VERSION = _("Version %s %s") %(getImageDistro(), getImageVersion())
class ImageBackup(Screen):
skin = """
<screen name="Image Backup" position="center,center" size="750,900" flags="wfNoBorder" backgroundColor="transparent">
<eLabel name="b" position="0,0" size="750,700" backgroundColor="#00ffffff" zPosition="-2" />
<eLabel name="a" position="1,1" size="748,698" backgroundColor="#00000000" zPosition="-1" />
<widget source="Title" render="Label" position="60,10" foregroundColor="#00ffffff" size="480,50" halign="left" font="Regular; 28" backgroundColor="#00000000" />
<eLabel name="line" position="1,60" size="748,1" backgroundColor="#00ffffff" zPosition="1" />
<eLabel name="line2" position="1,250" size="748,4" backgroundColor="#00ffffff" zPosition="1" />
<widget name="config" position="2,280" size="730,380" halign="center" font="Regular; 22" backgroundColor="#00000000" foregroundColor="#00e5b243" />
<widget source="description" render="Label" position="2,80" size="730,30" halign="center" font="Regular; 22" backgroundColor="#00000000" foregroundColor="#00ffffff" />
<widget source="options" render="Label" position="2,130" size="730,60" halign="center" font="Regular; 22" backgroundColor="#00000000" foregroundColor="#00ffffff" />
<widget source="key_red" render="Label" position="30,200" size="150,30" noWrap="1" zPosition="1" valign="center" font="Regular; 20" halign="left" backgroundColor="#00000000" foregroundColor="#00ffffff" />
from Components.ProgressBar import ProgressBar
from Screens.MessageBox import MessageBox
from Screens.ChoiceBox import ChoiceBox
from Screens.Screen import Screen
from Screens.MultiBootSelector import MultiBootSelector
from Components.Console import Console
from Tools.BoundFunction import boundFunction
from Tools.Multiboot import GetImagelist, GetCurrentImage, GetCurrentImageMode, GetBoxName
from enigma import eTimer, fbClass
import os, urllib2, json, shutil, math, time, zipfile, shutil
from boxbranding import getImageDistro, getMachineBuild, getMachineBrand, getMachineName, getMachineMtdRoot, getMachineMtdKernel
feedserver = 'images.mynonpublic.com'
feedurl = 'http://%s/%s/json' %(feedserver, getImageDistro())
def checkimagefiles(files):
return len([x for x in files if 'kernel' in x and '.bin' in x or x in ('zImage', 'uImage', 'root_cfe_auto.bin', 'root_cfe_auto.jffs2', 'oe_kernel.bin', 'oe_rootfs.bin', 'e2jffs2.img', 'rootfs.tar.bz2', 'rootfs.ubi','rootfs.bin')]) >= 2
class FlashOnline(Screen):
skin = """
<screen name="SelectImage" position="center,center" size="550,400">
<widget name="list" position="fill" scrollbarMode="showOnDemand"/>
</screen>"""
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.selection = 0
self.jsonlist = {}
def updateList(self):
self.list = []
try:
pluginpath = '/usr/lib/enigma2/python/Plugins/Extensions/NFR4XBoot'
f = open(pluginpath + '/.nfr4xboot_location', 'r')
mypath = f.readline().strip()
f.close()
except:
mypath = '/media/hdd'
icon = 'dev_usb.png'
if 'hdd' in mypath:
icon = 'dev_hdd.png'
icon = pluginpath + '/images/' + icon
png = LoadPixmap(icon)
self['device_icon'].instance.setPixmap(png)
device = '/media/nfr4xboot'
dev_free = dev_free_space = def_free_space_percent = ''
rc = os.system('df > /tmp/ninfo.tmp')
if fileExists('/tmp/ninfo.tmp'):
f = open('/tmp/ninfo.tmp', 'r')
for line in f.readlines():
line = line.replace('part1', ' ')
parts = line.strip().split()
totsp = len(parts) - 1
if parts[totsp] == device:
if totsp == 5:
dev_free = parts[1]
dev_free_space = parts[3]
def_free_space_percent = parts[4]
else:
dev_free = 'N/A '
dev_free_space = parts[2]
def_free_space_percent = parts[3]
break
f.close()
os.remove('/tmp/ninfo.tmp')
self.availablespace = dev_free_space[0:-3]
perc = int(def_free_space_percent[:-1])
self['free_space_progressbar'].setValue(perc)
green = '#00389416'
red = '#00ff2525'
yellow = '#00ffe875'
orange = '#00ff7f50'
if perc < 30:
color = green
elif perc < 60:
color = yellow
elif perc < 80:
color = orange
else:
color = red
self['label6'].instance.setForegroundColor(parseColor(color))
self['label7'].instance.setForegroundColor(parseColor(color))
self['label8'].instance.setForegroundColor(parseColor(color))
self['label9'].instance.setForegroundColor(parseColor(color))
self['label11'].instance.setForegroundColor(parseColor(color))
self['free_space_progressbar'].instance.setForegroundColor(
parseColor(color))
try:
f2 = open('/media/nfr4xboot/NFR4XBootI/.nfr4xboot', 'r')
mypath2 = f2.readline().strip()
f2.close()
except:
mypath2 = 'Flash'
if mypath2 == 'Flash':
image = getImageDistro()
if fileExists('/etc/image-version'):
if 'build' not in image:
f = open('/etc/image-version', 'r')
for line in f.readlines():
if 'build=' in line:
image = image + ' build ' + line[6:-1]
open('/media/nfr4xboot/NFR4XBootI/.Flash',
'w').write(image)
break
f.close()
elif fileExists('/media/nfr4xboot/NFR4XBootI/.Flash'):
f = open('/media/nfr4xboot/NFR4XBootI/.Flash', 'r')
image = f.readline().strip()
f.close()
image = ' [' + image + ']'
self.list.append('Flash' + image)
self['label6'].setText(mypath)
self['label7'].setText(def_free_space_percent)
self['label8'].setText(dev_free_space[0:-3] + ' MB')
self['label9'].setText(mypath2)
mypath = '/media/nfr4xboot/NFR4XBootI/'
myimages = os.listdir(mypath)
for fil in myimages:
if os.path.isdir(os.path.join(mypath, fil)):
self.list.append(fil)
self['label11'].setText(str(len(self.list) - 1))
self['config'].setList(self.list)
#!/usr/bin/python
# -*- coding: utf-8 -*-
import boxbranding
print("getVisionVersion=%s<" % boxbranding.getVisionVersion())
print("getVisionRevision=%s<" % boxbranding.getVisionRevision())
print("getDeveloperName=%s<" % boxbranding.getDeveloperName())
print("getBoxBrand=%s<" % boxbranding.getBoxBrand())
print("getOEVersion=%s<" % boxbranding.getOEVersion())
print("getImageDistro=%s<" % boxbranding.getImageDistro())
print("getBoxType=%s<" % boxbranding.getBoxType())
print("getMachineBuild=%s<" % boxbranding.getMachineBuild())
print("getImageVersion=%s<" % boxbranding.getImageVersion())
print("getImageBuild=%s<" % boxbranding.getImageBuild())
print("getImageDevBuild=%s<" % boxbranding.getImageDevBuild())
print("getImageType=%s<" % boxbranding.getImageType())
print("getFeedsUrl=%s<" % boxbranding.getFeedsUrl())
print("getImageFolder=%s<" % boxbranding.getImageFolder())
print("getImageFileSystem=%s<" % boxbranding.getImageFileSystem())
print("getMachineMtdBoot=%s<" % boxbranding.getMachineMtdBoot())
print("getMachineMtdRoot=%s<" % boxbranding.getMachineMtdRoot())
print("getMachineMtdKernel=%s<" % boxbranding.getMachineMtdKernel())
print("getMachineRootFile=%s<" % boxbranding.getMachineRootFile())
print("getMachineKernelFile=%s<" % boxbranding.getMachineKernelFile())
print("getMachineMKUBIFS=%s<" % boxbranding.getMachineMKUBIFS())
print("getMachineUBINIZE=%s<" % boxbranding.getMachineUBINIZE())
print("getForceMode=%s<" % boxbranding.getForceMode())
print("getImageArch=%s<" % boxbranding.getImageArch())
print("getImageFPU=%s<" % boxbranding.getImageFPU())
print("getDisplayType=%s<" % boxbranding.getDisplayType())
def getBackupPath():
backuppath = config.plugins.configurationbackup.backuplocation.value
if backuppath.endswith('/'):
return backuppath + 'backup_' + getImageDistro() + '_' + getBoxType()
else:
return backuppath + '/backup_' + getImageDistro() + '_' + getBoxType()
def getFriendlyImageDistro():
dist = boxbranding.getImageDistro().replace("openpli", "Open Pli")
return dist
def __init__(self, session, args=0):
Screen.__init__(self, session)
self.session = session
self.selection = 0
self.MODEL = getBoxType()
self.OEM = getBrandOEM()
self.MACHINEBUILD = getMachineBuild()
self.MACHINENAME = getMachineName()
self.MACHINEBRAND = getMachineBrand()
self.IMAGEFOLDER = getImageFolder()
self.HDFIMAGEVERSION = getImageVersion()
self.HDFIMAGEBUILD = getImageBuild()
self.HDFIMAGENAME = getImageDistro()
self.UBINIZE_ARGS = getMachineUBINIZE()
self.MKUBIFS_ARGS = getMachineMKUBIFS()
self.MTDKERNEL = getMachineMtdKernel()
self.MTDROOTFS = getMachineMtdRoot()
self.ROOTFSBIN = getMachineRootFile()
self.KERNELBIN = getMachineKernelFile()
self.ROOTFSTYPE = getImageFileSystem().strip()
if self.MACHINEBUILD in ("hd51", "vs1500", "h7", "8100s"):
self.MTDBOOT = "mmcblk0p1"
self.EMMCIMG = "disk.img"
elif self.MACHINEBUILD in ("xc7439", "osmio4k"):
self.MTDBOOT = "mmcblk1p1"
self.EMMCIMG = "emmc.img"
elif self.MACHINEBUILD in ("cc1", "sf8008", "ustym4kpr"):
self.MTDBOOT = "none"
self.EMMCIMG = "usb_update.bin"
else:
self.MTDBOOT = "none"
self.EMMCIMG = "none"
print "[FULL BACKUP] BOX MACHINEBUILD = >%s<" % self.MACHINEBUILD
print "[FULL BACKUP] BOX MACHINENAME = >%s<" % self.MACHINENAME
print "[FULL BACKUP] BOX MACHINEBRAND = >%s<" % self.MACHINEBRAND
print "[FULL BACKUP] BOX MODEL = >%s<" % self.MODEL
print "[FULL BACKUP] OEM MODEL = >%s<" % self.OEM
print "[FULL BACKUP] IMAGEFOLDER = >%s<" % self.IMAGEFOLDER
print "[FULL BACKUP] UBINIZE = >%s<" % self.UBINIZE_ARGS
print "[FULL BACKUP] MKUBIFS = >%s<" % self.MKUBIFS_ARGS
print "[FULL BACKUP] MTDBOOT = >%s<" % self.MTDBOOT
print "[FULL BACKUP] MTDKERNEL = >%s<" % self.MTDKERNEL
print "[FULL BACKUP] MTDROOTFS = >%s<" % self.MTDROOTFS
print "[FULL BACKUP] ROOTFSBIN = >%s<" % self.ROOTFSBIN
print "[FULL BACKUP] KERNELBIN = >%s<" % self.KERNELBIN
print "[FULL BACKUP] ROOTFSTYPE = >%s<" % self.ROOTFSTYPE
print "[FULL BACKUP] EMMCIMG = >%s<" % self.EMMCIMG
if isDreamboxXZ:
self.IMAGEFOLDER = self.MODEL
# fix me to xz
self.ROOTFSTYPE = "tar.gz"
self.ROOTFSBIN = "root.tar.gz"
self.error_files = ''
self.list = self.list_files("/boot")
self["key_green"] = Button("USB")
self["key_red"] = Button("HDD")
self["key_blue"] = Button(_("Exit"))
if SystemInfo["HaveMultiBoot"]:
self["key_yellow"] = Button(_("Select Multiboot"))
self["info-multi"] = Label(
_("You can select with yellow the OnlineFlash Image\n or select Recovery to create a USB Disk Image for clean Install."
))
self.read_current_multiboot()
else:
self["key_yellow"] = Button("")
self["info-multi"] = Label(" ")
self["info-usb"] = Label(
_("USB = Do you want to make a back-up on USB?\nThis will take between 4 and 15 minutes depending on the used filesystem and is fully automatic.\nMake sure you first insert an USB flash drive before you select USB.\nThis USB drive must contain a file with the name\nbackupstick or backupstick.txt."
))
self["info-hdd"] = Label(
_("HDD = Do you want to make an USB-back-up image on HDD? \nThis only takes 2 or 10 minutes and is fully automatic."
))
self["actions"] = ActionMap(
["OkCancelActions", "ColorActions"], {
"blue": self.quit,
"yellow": self.yellow,
"green": self.green,
"red": self.red,
"cancel": self.quit,
}, -2)
self.onShown.append(self.show_Errors)
def doFullBackup(self, answer):
if answer is not None:
if answer[1]:
self.RECOVERY = answer[3]
self.DIRECTORY = "%s/images" %answer[2]
if not os.path.exists(self.DIRECTORY):
try:
os.makedirs(self.DIRECTORY)
except:
self.session.open(MessageBox, _("Cannot create backup directory"), MessageBox.TYPE_ERROR, timeout=10)
return
self.SLOT = answer[1]
self.MODEL = GetBoxName()
self.OEM = getBrandOEM()
self.MACHINEBUILD = getMachineBuild()
self.MACHINENAME = getMachineName()
self.MACHINEBRAND = getMachineBrand()
self.IMAGEFOLDER = getImageFolder()
self.UBINIZE_ARGS = getMachineUBINIZE()
self.MKUBIFS_ARGS = getMachineMKUBIFS()
self.ROOTFSSUBDIR = "none"
self.ROOTFSBIN = getMachineRootFile()
self.KERNELBIN = getMachineKernelFile()
self.ROOTFSTYPE = getImageFileSystem().strip()
self.IMAGEDISTRO = getImageDistro()
self.DISTROVERSION = getImageVersion()
if SystemInfo["canRecovery"]:
self.EMMCIMG = SystemInfo["canRecovery"][0]
self.MTDBOOT = SystemInfo["canRecovery"][1]
else:
self.EMMCIMG = "none"
self.MTDBOOT = "none"
self.getImageList = self.saveImageList
if SystemInfo["canMultiBoot"]:
self.MTDKERNEL = SystemInfo["canMultiBoot"][self.SLOT]["kernel"].split('/')[2]
self.MTDROOTFS = SystemInfo["canMultiBoot"][self.SLOT]["device"].split('/')[2]
if SystemInfo["HasRootSubdir"]:
self.ROOTFSSUBDIR = SystemInfo["canMultiBoot"][self.SLOT]['rootsubdir']
else:
self.MTDKERNEL = getMachineMtdKernel()
self.MTDROOTFS = getMachineMtdRoot()
print "[Image Backup] BOX MACHINEBUILD = >%s<" %self.MACHINEBUILD
print "[Image Backup] BOX MACHINENAME = >%s<" %self.MACHINENAME
print "[Image Backup] BOX MACHINEBRAND = >%s<" %self.MACHINEBRAND
print "[Image Backup] BOX MODEL = >%s<" %self.MODEL
print "[Image Backup] OEM MODEL = >%s<" %self.OEM
print "[Image Backup] IMAGEFOLDER = >%s<" %self.IMAGEFOLDER
print "[Image Backup] UBINIZE = >%s<" %self.UBINIZE_ARGS
print "[Image Backup] MKUBIFS = >%s<" %self.MKUBIFS_ARGS
print "[Image Backup] MTDBOOT = >%s<" %self.MTDBOOT
print "[Image Backup] MTDKERNEL = >%s<" %self.MTDKERNEL
print "[Image Backup] MTDROOTFS = >%s<" %self.MTDROOTFS
print "[Image Backup] ROOTFSBIN = >%s<" %self.ROOTFSBIN
print "[Image Backup] KERNELBIN = >%s<" %self.KERNELBIN
print "[Image Backup] ROOTFSSUBDIR = >%s<" %self.ROOTFSSUBDIR
print "[Image Backup] ROOTFSTYPE = >%s<" %self.ROOTFSTYPE
print "[Image Backup] EMMCIMG = >%s<" %self.EMMCIMG
print "[Image Backup] IMAGEDISTRO = >%s<" %self.IMAGEDISTRO
print "[Image Backup] DISTROVERSION = >%s<" %self.DISTROVERSION
print "[Image Backup] MTDBOOT = >%s<" %self.MTDBOOT
print "[Image Backup] USB RECOVERY = >%s< " %self.RECOVERY
print "[Image Backup] DESTINATION = >%s< " %self.DIRECTORY
print "[Image Backup] SLOT = >%s< " %self.SLOT
self.TITLE = _("Full back-up on %s") % (self.DIRECTORY)
self.START = time()
self.DATE = strftime("%Y%m%d_%H%M", localtime(self.START))
self.IMAGEVERSION = self.imageInfo()
self.MKFS_UBI = "/usr/sbin/mkfs.ubifs"
self.MKFS_TAR = "/bin/tar"
self.BZIP2 = "/usr/bin/bzip2"
self.MKFS_JFFS2 = "/usr/sbin/mkfs.jffs2"
self.UBINIZE = "/usr/sbin/ubinize"
self.NANDDUMP = "/usr/sbin/nanddump"
self.FASTBOOT = "/usr/bin/ext2simg"
self.WORKDIR= "%s/bi" %self.DIRECTORY
self.SHOWNAME = "%s %s" %(self.MACHINEBRAND, self.MODEL)
self.MAINDEST = "%s/build_%s/%s" % (self.DIRECTORY, self.MODEL, self.IMAGEFOLDER)
self.MAINDESTROOT = "%s/build_%s" % (self.DIRECTORY, self.MODEL)
self.message = "echo -e '\n"
if getMachineBrand().startswith('A') or getMachineBrand().startswith('E') or getMachineBrand().startswith('I') or getMachineBrand().startswith('O') or getMachineBrand().startswith('U') or getMachineBrand().startswith('Xt'):
self.message += (_('Back-up Tool for an %s\n') % self.SHOWNAME).upper()
else:
self.message += (_('Back-up Tool for a %s\n') % self.SHOWNAME).upper()
self.message += VERSION + '\n'
self.message += "_________________________________________________\n\n"
self.message += _("Please be patient, a backup will now be made,\n")
self.message += _("because of the used filesystem the back-up\n")
self.message += _("will take about 1-15 minutes for this system\n")
self.message += "_________________________________________________\n\n"
if self.RECOVERY:
self.message += _("Backup Mode: USB Recovery\n")
else:
self.message += _("Backup Mode: Flash Online\n")
self.message += "_________________________________________________\n"
self.message += "'"
## PREPARING THE BUILDING ENVIRONMENT
os.system("rm -rf %s" %self.WORKDIR)
self.backuproot = "/tmp/bi/root"
if SystemInfo["HasRootSubdir"]:
self.backuproot = "/tmp/bi/RootSubdir/"
if not os.path.exists(self.WORKDIR):
os.makedirs(self.WORKDIR)
if not os.path.exists(self.backuproot):
os.makedirs(self.backuproot)
os.system("sync")
if SystemInfo["canMultiBoot"]:
if SystemInfo["HasRootSubdir"]:
os.system("mount /dev/%s /tmp/bi/RootSubdir" %self.MTDROOTFS)
self.backuproot = self.backuproot + self.ROOTFSSUBDIR
else:
os.system("mount /dev/%s %s" %(self.MTDROOTFS, self.backuproot))
else:
os.system("mount --bind / %s" %(self.backuproot))
if "jffs2" in self.ROOTFSTYPE.split():
cmd1 = "%s --root=%s --faketime --output=%s/root.jffs2 %s" % (self.MKFS_JFFS2, self.backuproot, self.WORKDIR, self.MKUBIFS_ARGS)
cmd2 = None
cmd3 = None
elif "ubi" in self.ROOTFSTYPE.split():
f = open("%s/ubinize.cfg" %self.WORKDIR, "w")
f.write("[ubifs]\n")
f.write("mode=ubi\n")
f.write("image=%s/root.ubi\n" %self.WORKDIR)
f.write("vol_id=0\n")
f.write("vol_type=dynamic\n")
f.write("vol_name=rootfs\n")
f.write("vol_flags=autoresize\n")
f.close()
ff = open("%s/root.ubi" %self.WORKDIR, "w")
ff.close()
cmd1 = "%s -r %s -o %s/root.ubi %s" % (self.MKFS_UBI, self.backuproot, self.WORKDIR, self.MKUBIFS_ARGS)
cmd2 = "%s -o %s/root.ubifs %s %s/ubinize.cfg" % (self.UBINIZE, self.WORKDIR, self.UBINIZE_ARGS, self.WORKDIR)
cmd3 = "mv %s/root.ubifs %s/root.%s" %(self.WORKDIR, self.WORKDIR, self.ROOTFSTYPE)
else:
if self.RECOVERY:
cmd1 = None
cmd2 = None
else:
cmd1 = "%s -cf %s/rootfs.tar -C %s --exclude ./var/nmbd --exclude ./.resizerootfs --exclude ./.resize-rootfs --exclude ./.resize-linuxrootfs --exclude ./.resize-userdata --exclude ./var/lib/samba/private/msg.sock --exclude ./var/lib/samba/msg.sock/* --exclude ./run/avahi-daemon/socket ." % (self.MKFS_TAR, self.WORKDIR, self.backuproot)
cmd2 = "%s %s/rootfs.tar" % (self.BZIP2, self.WORKDIR)
cmd3 = None
cmdlist = []
cmdlist.append(self.message)
if cmd1:
cmdlist.append('echo "' + _("Create:") + ' %s"' %self.ROOTFSBIN)
cmdlist.append(cmd1)
if cmd2:
cmdlist.append(cmd2)
if cmd3:
cmdlist.append(cmd3)
if self.MODEL in ("gbquad4k","gbue4k","gbx34k"):
cmdlist.append('echo "' + _("Create:") + " boot dump" + '"')
cmdlist.append("dd if=/dev/mmcblk0p1 of=%s/boot.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " rescue dump" + '"')
cmdlist.append("dd if=/dev/mmcblk0p3 of=%s/rescue.bin" % self.WORKDIR)
if self.MACHINEBUILD in ("h9","i55plus"):
cmdlist.append('echo "' + _("Create:") + " fastboot dump" + '"')
cmdlist.append("dd if=/dev/mtd0 of=%s/fastboot.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " bootargs dump" + '"')
cmdlist.append("dd if=/dev/mtd1 of=%s/bootargs.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " baseparam dump" + '"')
cmdlist.append("dd if=/dev/mtd2 of=%s/baseparam.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " pq_param dump" + '"')
cmdlist.append("dd if=/dev/mtd3 of=%s/pq_param.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " logo dump" + '"')
cmdlist.append("dd if=/dev/mtd4 of=%s/logo.bin" % self.WORKDIR)
if self.EMMCIMG == "usb_update.bin" and self.RECOVERY:
SEEK_CONT = (Harddisk.getFolderSize(self.backuproot)/ 1024) + 100000
cmdlist.append('echo "' + _("Create:") + " fastboot dump" + '"')
cmdlist.append('cp -f /usr/share/fastboot.bin %s/fastboot.bin' %(self.WORKDIR))
#cmdlist.append("dd if=/dev/mmcblk0p1 of=%s/fastboot.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " bootargs dump" + '"')
cmdlist.append('cp -f /usr/share/bootargs.bin %s/bootargs.bin' %(self.WORKDIR))
#cmdlist.append("dd if=/dev/mmcblk0p2 of=%s/bootargs.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " boot dump" + '"')
cmdlist.append("dd if=/dev/mmcblk0p3 of=%s/boot.img" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " baseparam dump" + '"')
#cmdlist.append('cp -f /usr/share/bootargs.bin %s/baseparam.img' %(self.WORKDIR))
cmdlist.append("dd if=/dev/mmcblk0p4 of=%s/baseparam.img" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " pq_param dump" + '"')
#cmdlist.append('cp -f /usr/share/bootargs.bin %s/pq_param.bin' %(self.WORKDIR))
cmdlist.append("dd if=/dev/mmcblk0p5 of=%s/pq_param.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " logo dump" + '"')
cmdlist.append("dd if=/dev/mmcblk0p6 of=%s/logo.img" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " deviceinfo dump" + '"')
#cmdlist.append('cp -f /usr/share/bootargs.bin %s/deviceinfo.bin' %(self.WORKDIR))
cmdlist.append("dd if=/dev/mmcblk0p7 of=%s/deviceinfo.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " apploader dump" + '"')
cmdlist.append('cp -f /usr/share/apploader.bin %s/apploader.bin' %(self.WORKDIR))
#cmdlist.append("dd if=/dev/mmcblk0p10 of=%s/apploader.bin" % self.WORKDIR)
cmdlist.append('echo "' + _("Create:") + " rootfs dump" + '"')
cmdlist.append("dd if=/dev/zero of=%s/rootfs.ext4 seek=%s count=60 bs=1024" % (self.WORKDIR, SEEK_CONT))
cmdlist.append("mkfs.ext4 -F -i 4096 %s/rootfs.ext4" % (self.WORKDIR))
cmdlist.append("mkdir -p %s/userdata" % self.WORKDIR)
cmdlist.append("mount %s/rootfs.ext4 %s/userdata" %(self.WORKDIR,self.WORKDIR))
cmdlist.append("mkdir -p %s/userdata/linuxrootfs1" % self.WORKDIR)
cmdlist.append("mkdir -p %s/userdata/linuxrootfs2" % self.WORKDIR)
cmdlist.append("mkdir -p %s/userdata/linuxrootfs3" % self.WORKDIR)
cmdlist.append("mkdir -p %s/userdata/linuxrootfs4" % self.WORKDIR)
cmdlist.append("rsync -aAX %s/ %s/userdata/linuxrootfs1/" % (self.backuproot,self.WORKDIR))
cmdlist.append("umount %s/userdata" %(self.WORKDIR))
cmdlist.append('echo "' + _("Create:") + " kerneldump" + '"')
if SystemInfo["canMultiBoot"] or self.MTDKERNEL.startswith('mmcblk0'):
cmdlist.append("dd if=/dev/%s of=%s/%s" % (self.MTDKERNEL ,self.WORKDIR, self.KERNELBIN))
else:
cmdlist.append("nanddump -a -f %s/vmlinux.gz /dev/%s" % (self.WORKDIR, self.MTDKERNEL))
if self.EMMCIMG == "disk.img" and self.RECOVERY:
EMMC_IMAGE = "%s/%s"% (self.WORKDIR,self.EMMCIMG)
BLOCK_SIZE=512
BLOCK_SECTOR=2
IMAGE_ROOTFS_ALIGNMENT=1024
BOOT_PARTITION_SIZE=3072
KERNEL_PARTITION_SIZE=8192
ROOTFS_PARTITION_SIZE=1048576
EMMC_IMAGE_SIZE=3817472
KERNEL_PARTITION_OFFSET = int(IMAGE_ROOTFS_ALIGNMENT) + int(BOOT_PARTITION_SIZE)
ROOTFS_PARTITION_OFFSET = int(KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
SECOND_KERNEL_PARTITION_OFFSET = int(ROOTFS_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
THRID_KERNEL_PARTITION_OFFSET = int(SECOND_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
FOURTH_KERNEL_PARTITION_OFFSET = int(THRID_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
MULTI_ROOTFS_PARTITION_OFFSET = int(FOURTH_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
EMMC_IMAGE_SEEK = int(EMMC_IMAGE_SIZE) * int(BLOCK_SECTOR)
cmdlist.append('echo "' + _("Create: Recovery Fullbackup %s")% (self.EMMCIMG) + '"')
cmdlist.append('dd if=/dev/zero of=%s bs=%s count=0 seek=%s' % (EMMC_IMAGE, BLOCK_SIZE , EMMC_IMAGE_SEEK))
cmdlist.append('parted -s %s mklabel gpt' %EMMC_IMAGE)
PARTED_END_BOOT = int(IMAGE_ROOTFS_ALIGNMENT) + int(BOOT_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart boot fat16 %s %s' % (EMMC_IMAGE, IMAGE_ROOTFS_ALIGNMENT, PARTED_END_BOOT ))
PARTED_END_KERNEL1 = int(KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart linuxkernel %s %s' % (EMMC_IMAGE, KERNEL_PARTITION_OFFSET, PARTED_END_KERNEL1 ))
PARTED_END_ROOTFS1 = int(ROOTFS_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart linuxrootfs ext4 %s %s' % (EMMC_IMAGE, ROOTFS_PARTITION_OFFSET, PARTED_END_ROOTFS1 ))
PARTED_END_KERNEL2 = int(SECOND_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart linuxkernel2 %s %s' % (EMMC_IMAGE, SECOND_KERNEL_PARTITION_OFFSET, PARTED_END_KERNEL2 ))
PARTED_END_KERNEL3 = int(THRID_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart linuxkernel3 %s %s' % (EMMC_IMAGE, THRID_KERNEL_PARTITION_OFFSET, PARTED_END_KERNEL3 ))
PARTED_END_KERNEL4 = int(FOURTH_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart linuxkernel4 %s %s' % (EMMC_IMAGE, FOURTH_KERNEL_PARTITION_OFFSET, PARTED_END_KERNEL4 ))
rd = open("/proc/swaps", "r").read()
if "mmcblk0p7" in rd:
SWAP_PARTITION_OFFSET = int(FOURTH_KERNEL_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
SWAP_PARTITION_SIZE = int(262144)
MULTI_ROOTFS_PARTITION_OFFSET = int(SWAP_PARTITION_OFFSET) + int(SWAP_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart swap linux-swap %s %s' % (EMMC_IMAGE, SWAP_PARTITION_OFFSET, SWAP_PARTITION_OFFSET + SWAP_PARTITION_SIZE))
cmdlist.append('parted -s %s unit KiB mkpart userdata ext4 %s 100%%' % (EMMC_IMAGE, MULTI_ROOTFS_PARTITION_OFFSET))
else:
cmdlist.append('parted -s %s unit KiB mkpart userdata ext4 %s 100%%' % (EMMC_IMAGE, MULTI_ROOTFS_PARTITION_OFFSET))
BOOT_IMAGE_SEEK = int(IMAGE_ROOTFS_ALIGNMENT) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s' % (self.MTDBOOT, EMMC_IMAGE, BOOT_IMAGE_SEEK ))
KERNAL_IMAGE_SEEK = int(KERNEL_PARTITION_OFFSET) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s' % (self.MTDKERNEL, EMMC_IMAGE, KERNAL_IMAGE_SEEK ))
ROOTFS_IMAGE_SEEK = int(ROOTFS_PARTITION_OFFSET) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s ' % (self.MTDROOTFS, EMMC_IMAGE, ROOTFS_IMAGE_SEEK ))
elif self.EMMCIMG == "emmc.img" and self.RECOVERY:
EMMC_IMAGE = "%s/%s"% (self.WORKDIR,self.EMMCIMG)
BLOCK_SECTOR=2
IMAGE_ROOTFS_ALIGNMENT=1024
BOOT_PARTITION_SIZE=3072
KERNEL_PARTITION_SIZE=8192
ROOTFS_PARTITION_SIZE=1898496
EMMC_IMAGE_SIZE=7634944
BOOTDD_VOLUME_ID = "boot"
KERNEL1_PARTITION_OFFSET = int(IMAGE_ROOTFS_ALIGNMENT) + int(BOOT_PARTITION_SIZE)
ROOTFS1_PARTITION_OFFSET = int(KERNEL1_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
KERNEL2_PARTITION_OFFSET = int(ROOTFS1_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
ROOTFS2_PARTITION_OFFSET = int(KERNEL2_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
KERNEL3_PARTITION_OFFSET = int(ROOTFS2_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
ROOTFS3_PARTITION_OFFSET = int(KERNEL3_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
KERNEL4_PARTITION_OFFSET = int(ROOTFS3_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
ROOTFS4_PARTITION_OFFSET = int(KERNEL4_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
EMMC_IMAGE_SEEK = int(EMMC_IMAGE_SIZE) * int(IMAGE_ROOTFS_ALIGNMENT)
cmdlist.append('echo "' + _("Create: Recovery Fullbackup %s")% (self.EMMCIMG) + '"')
cmdlist.append('dd if=/dev/zero of=%s bs=1 count=0 seek=%s' % (EMMC_IMAGE, EMMC_IMAGE_SEEK))
cmdlist.append('parted -s %s mklabel gpt' %EMMC_IMAGE)
PARTED_END_BOOT = int(IMAGE_ROOTFS_ALIGNMENT) + int(BOOT_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart boot fat16 %s %s' % (EMMC_IMAGE, IMAGE_ROOTFS_ALIGNMENT, PARTED_END_BOOT ))
cmdlist.append('parted -s %s set 1 boot on' %EMMC_IMAGE)
PARTED_END_KERNEL1 = int(KERNEL1_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart kernel1 %s %s' % (EMMC_IMAGE, KERNEL1_PARTITION_OFFSET, PARTED_END_KERNEL1 ))
PARTED_END_ROOTFS1 = int(ROOTFS1_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart rootfs1 ext4 %s %s' % (EMMC_IMAGE, ROOTFS1_PARTITION_OFFSET, PARTED_END_ROOTFS1 ))
PARTED_END_KERNEL2 = int(KERNEL2_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart kernel2 %s %s' % (EMMC_IMAGE, KERNEL2_PARTITION_OFFSET, PARTED_END_KERNEL2 ))
PARTED_END_ROOTFS2 = int(ROOTFS2_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart rootfs2 ext4 %s %s' % (EMMC_IMAGE, ROOTFS2_PARTITION_OFFSET, PARTED_END_ROOTFS2 ))
PARTED_END_KERNEL3 = int(KERNEL3_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart kernel3 %s %s' % (EMMC_IMAGE, KERNEL3_PARTITION_OFFSET, PARTED_END_KERNEL3 ))
PARTED_END_ROOTFS3 = int(ROOTFS3_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart rootfs3 ext4 %s %s' % (EMMC_IMAGE, ROOTFS3_PARTITION_OFFSET, PARTED_END_ROOTFS3 ))
PARTED_END_KERNEL4 = int(KERNEL4_PARTITION_OFFSET) + int(KERNEL_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart kernel4 %s %s' % (EMMC_IMAGE, KERNEL4_PARTITION_OFFSET, PARTED_END_KERNEL4 ))
PARTED_END_ROOTFS4 = int(ROOTFS4_PARTITION_OFFSET) + int(ROOTFS_PARTITION_SIZE)
cmdlist.append('parted -s %s unit KiB mkpart rootfs4 ext4 %s %s' % (EMMC_IMAGE, ROOTFS4_PARTITION_OFFSET, PARTED_END_ROOTFS4 ))
BOOT_IMAGE_SEEK = int(IMAGE_ROOTFS_ALIGNMENT) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s' % (self.MTDBOOT, EMMC_IMAGE, BOOT_IMAGE_SEEK ))
KERNAL_IMAGE_SEEK = int(KERNEL1_PARTITION_OFFSET) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s' % (self.MTDKERNEL, EMMC_IMAGE, KERNAL_IMAGE_SEEK ))
ROOTFS_IMAGE_SEEK = int(ROOTFS1_PARTITION_OFFSET) * int(BLOCK_SECTOR)
cmdlist.append('dd if=/dev/%s of=%s seek=%s ' % (self.MTDROOTFS, EMMC_IMAGE, ROOTFS_IMAGE_SEEK ))
elif self.EMMCIMG == "usb_update.bin" and self.RECOVERY:
cmdlist.append('echo "' + _("Create: Recovery Fullbackup %s")% (self.EMMCIMG) + '"')
f = open("%s/emmc_partitions.xml" %self.WORKDIR, "w")
f.write('<?xml version="1.0" encoding="GB2312" ?>\n')
f.write('<Partition_Info>\n')
f.write('<Part Sel="1" PartitionName="fastboot" FlashType="emmc" FileSystem="none" Start="0" Length="1M" SelectFile="fastboot.bin"/>\n')
f.write('<Part Sel="1" PartitionName="bootargs" FlashType="emmc" FileSystem="none" Start="1M" Length="1M" SelectFile="bootargs.bin"/>\n')
f.write('<Part Sel="1" PartitionName="bootoptions" FlashType="emmc" FileSystem="none" Start="2M" Length="1M" SelectFile="boot.img"/>\n')
f.write('<Part Sel="1" PartitionName="baseparam" FlashType="emmc" FileSystem="none" Start="3M" Length="3M" SelectFile="baseparam.img"/>\n')
f.write('<Part Sel="1" PartitionName="pqparam" FlashType="emmc" FileSystem="none" Start="6M" Length="4M" SelectFile="pq_param.bin"/>\n')
f.write('<Part Sel="1" PartitionName="logo" FlashType="emmc" FileSystem="none" Start="10M" Length="4M" SelectFile="logo.img"/>\n')
f.write('<Part Sel="1" PartitionName="deviceinfo" FlashType="emmc" FileSystem="none" Start="14M" Length="4M" SelectFile="deviceinfo.bin"/>\n')
f.write('<Part Sel="1" PartitionName="loader" FlashType="emmc" FileSystem="none" Start="26M" Length="32M" SelectFile="apploader.bin"/>\n')
f.write('<Part Sel="1" PartitionName="linuxkernel1" FlashType="emmc" FileSystem="none" Start="66M" Length="16M" SelectFile="kernel.bin"/>\n')
if self.MACHINEBUILD in ("sf8008m"):
f.write('<Part Sel="1" PartitionName="userdata" FlashType="emmc" FileSystem="ext3/4" Start="130M" Length="3580M" SelectFile="rootfs.ext4"/>\n')
else:
f.write('<Part Sel="1" PartitionName="userdata" FlashType="emmc" FileSystem="ext3/4" Start="130M" Length="7000M" SelectFile="rootfs.ext4"/>\n')
f.write('</Partition_Info>\n')
f.close()
cmdlist.append('mkupdate -s 00000003-00000001-01010101 -f %s/emmc_partitions.xml -d %s/%s' % (self.WORKDIR,self.WORKDIR,self.EMMCIMG))
self.session.open(Console, title = self.TITLE, cmdlist = cmdlist, finishedCallback = self.doFullBackupCB, closeOnSuccess = True)
else:
self.close()
else:
self.close()
def confirm(self, confirmed):
if not confirmed:
print "not confirmed"
self.close()
else:
var = self["list"].getSelectionIndex()
self.rcuv = self.rcuval[var]
#if self.rcuv != self.rcuold: copy keymap
try:
if self.rcuv == 'WeTek Play2 RCU':
os.system(
"cp -f /etc/amremote/wetek_play2.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'WeTek Play (Classic) RCU':
os.system(
"cp -f /etc/amremote/wetek1.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'WeTek Play OpenElec RCU':
os.system(
"cp -f /etc/amremote/wetek3.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'AB IPBox 9900/99/55 HD RCU':
os.system(
"cp -f /etc/amremote/wetek_ipbox9900remote.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Alien2/1 RCU':
os.system(
"cp -f /etc/amremote/alien2.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Alien1 old RCU':
os.system(
"cp -f /etc/amremote/alien.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'GI LX3 RCU':
os.system(
"cp -f /etc/amremote/gilx3.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Gigablue 800 UE Plus RCU':
os.system(
"cp -f /etc/amremote/gb800ueplus.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Mutant HD2400 RCU':
os.system(
"cp -f /etc/amremote/wetek_hd2400remote.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Octagon SF8 RCU':
os.system(
"cp -f /etc/amremote/octagonsf8.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Technomate Nano RCU':
os.system(
"cp -f /etc/amremote/wetek_tmnanoremote.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'xtrend ET10000 RCU':
os.system(
"cp -f /etc/amremote/wetek_et10000remote.conf /etc/amremote/wetek.conf &"
)
elif self.rcuv == 'Zgemma Star RCU':
os.system(
"cp -f /etc/amremote/zgemmastar.conf /etc/amremote/wetek.conf &"
)
else:
os.system(
"cp -f /etc/amremote/wetek2.conf /etc/amremote/wetek.conf &"
)
f = open("/etc/amremote/.choice", "w")
f.write(self.rcuv)
f.close()
os.system("killall -9 remotecfg &")
boxime = HardwareInfo().get_device_name()
if boxime == 'wetekplay2':
fin = file('/etc/amremote/wetek.conf')
fout = open('/etc/amremote/wetek_tmp.conf', 'w')
for line in fin:
if 'work_mode' in line: line = 'work_mode = 0\n'
fout.write(line)
fout.close()
os.system(
'mv -f /etc/amremote/wetek_tmp.conf /etc/amremote/wetek.conf &'
)
os.system("/usr/bin/remotecfg /etc/amremote/wetek.conf &")
if self.rcuold == "WeTek Play OpenElec RCU" or self.rcuv == "WeTek Play OpenElec RCU":
if self.rcuold != self.rcuv:
if self.rcuv == 'WeTek Play OpenElec RCU':
if getImageDistro() == "openspa":
os.system(
"cp -f /usr/lib/enigma2/python/Plugins/Extensions/RCUSelect/conf/keymap_OpenELEC.xml /usr/share/enigma2/keymap.xml &"
)
else:
os.system(
"cp -f /usr/lib/enigma2/python/Plugins/Extensions/RCUSelect/conf/keymap.OE.xml /usr/share/enigma2/keymap.xml &"
)
else:
os.system(
"cp -f /usr/lib/enigma2/python/Plugins/Extensions/RCUSelect/conf/keymap.orig.xml /usr/share/enigma2/keymap.xml &"
)
os.system("killall -9 enigma2 &")
else:
os.system(
"cp -f /usr/lib/enigma2/python/Plugins/Extensions/RCUSelect/conf/keymap.orig.xml /usr/share/enigma2/keymap.xml &"
)
except IOError:
print "RCU select failed."
self.close()
from Screens.Console import Console as ScreenConsole
from Screens.MessageBox import MessageBox
from Screens.Standby import TryQuitMainloop
from Tools.Notifications import AddPopupWithCallback
RAMCHEKFAILEDID = 'RamCheckFailedNotification'
hddchoises = []
for p in harddiskmanager.getMountedPartitions():
if path.exists(p.mountpoint):
d = path.normpath(p.mountpoint)
if p.mountpoint != '/':
hddchoises.append((p.mountpoint, d))
config.imagemanager = ConfigSubsection()
config.imagemanager.folderprefix = ConfigText(default=getImageDistro() + '-' +
getBoxType(),
fixed_size=False)
config.imagemanager.backuplocation = ConfigSelection(choices=hddchoises)
config.imagemanager.schedule = ConfigYesNo(default=False)
config.imagemanager.scheduletime = ConfigClock(default=0) # 1:00
config.imagemanager.repeattype = ConfigSelection(default="daily",
choices=[
("daily", _("Daily")),
("weekly", _("Weekly")),
("monthly", _("30 Days"))
])
config.imagemanager.backupretry = ConfigNumber(default=30)
config.imagemanager.backupretrycount = NoSave(ConfigNumber(default=0))
config.imagemanager.nextscheduletime = NoSave(ConfigNumber(default=0))
config.imagemanager.restoreimage = NoSave(
def Plugins(**kwargs):
screenwidth = getDesktop(0).size().width()
try:
from boxbranding import getImageDistro
if getImageDistro() == "openatv":
list = []
list.append(
PluginDescriptor(
name="Setup KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_MENU,
fnc=main_menu))
if screenwidth and screenwidth == 1920:
list.append(
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='pluginfhd.png',
fnc=main))
else:
list.append(
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='plugin.png',
fnc=main))
return list
else:
if screenwidth and screenwidth == 1920:
return [
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='pluginfhd.png',
fnc=main)
]
else:
return [
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='plugin.png',
fnc=main)
]
except ImportError:
if screenwidth and screenwidth == 1920:
return [
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='pluginfhd.png',
fnc=main)
]
else:
return [
PluginDescriptor(
name="KravenVB",
description=_("Configuration tool for KravenVB"),
where=PluginDescriptor.WHERE_PLUGINMENU,
icon='plugin.png',
fnc=main)
]
def createConfig(self):
self.mountusingEntry = None
self.sharenameEntry = None
self.mounttypeEntry = None
self.activeEntry = None
self.ipEntry = None
self.sharedirEntry = None
self.optionsEntry = None
self.usernameEntry = None
self.passwordEntry = None
self.hdd_replacementEntry = None
self.mountusing = []
self.mountusing.append(("autofs", _("AUTOFS (mount as needed)")))
self.mountusing.append(("fstab", _("FSTAB (mount at boot)")))
self.mountusing.append(("enigma2", _("Enigma2 (mount using enigma2)")))
self.mountusing.append(("old_enigma2", _("Enigma2 old format (mount using linux)")))
self.sharetypelist = []
self.sharetypelist.append(("cifs", _("CIFS share")))
self.sharetypelist.append(("nfs", _("NFS share")))
mountusing_default = "fstab"
if getImageDistro() in ("openvix", "easy-gui-aus", "beyonwiz", "openatv", "openhdf"):
mountusing_default = "autofs"
if 'mountusing' in self.mountinfo:
mountusing = self.mountinfo['mountusing']
if mountusing is False:
mountusing = mountusing_default
else:
mountusing = mountusing_default
if 'mounttype' in self.mountinfo:
mounttype = self.mountinfo['mounttype']
if mounttype is False:
mounttype = "nfs"
else:
mounttype = "nfs"
if 'active' in self.mountinfo:
active = self.mountinfo['active']
if active == 'True':
active = True
if active == 'False':
active = False
else:
active = True
if 'ip' in self.mountinfo:
if self.mountinfo['ip'] is False:
ip = [192, 168, 0, 0]
else:
ip = self.convertIP(self.mountinfo['ip'])
else:
ip = [192, 168, 0, 0]
if mounttype == "nfs":
defaultOptions = "rw,nolock,tcp"
else:
defaultOptions = "rw,utf8,vers=2.0"
if self.mountinfo['sharename'] and 'sharename' in self.mountinfo:
sharename = re_sub("\W", "", self.mountinfo['sharename'])
self.old_sharename = sharename
else:
sharename = ""
self.old_sharename = None
if 'sharedir' in self.mountinfo:
sharedir = self.mountinfo['sharedir']
self.old_sharedir = sharedir
else:
sharedir = ""
self.old_sharedir = None
if 'options' in self.mountinfo:
options = self.mountinfo['options']
else:
options = defaultOptions
if 'username' in self.mountinfo:
username = self.mountinfo['username']
else:
username = ""
if 'password' in self.mountinfo:
password = self.mountinfo['password']
else:
password = ""
if 'hdd_replacement' in self.mountinfo:
hdd_replacement = self.mountinfo['hdd_replacement']
if hdd_replacement == 'True':
hdd_replacement = True
if hdd_replacement == 'False':
hdd_replacement = False
else:
hdd_replacement = False
if sharename is False:
sharename = ""
if sharedir is False:
sharedir = ""
if username is False:
username = ""
if password is False:
password = ""
self.mountusingConfigEntry = NoSave(ConfigSelection(self.mountusing, default=mountusing))
self.activeConfigEntry = NoSave(ConfigEnableDisable(default=active))
self.ipConfigEntry = NoSave(ConfigIP(default=ip))
self.sharenameConfigEntry = NoSave(ConfigText(default=sharename, visible_width=50, fixed_size=False))
self.sharedirConfigEntry = NoSave(ConfigText(default=sharedir, visible_width=50, fixed_size=False))
self.optionsConfigEntry = NoSave(ConfigText(default=defaultOptions, visible_width=50, fixed_size=False))
if options is not False:
self.optionsConfigEntry.value = options
self.usernameConfigEntry = NoSave(ConfigText(default=username, visible_width=50, fixed_size=False))
self.passwordConfigEntry = NoSave(ConfigPassword(default=password, visible_width=50, fixed_size=False))
self.mounttypeConfigEntry = NoSave(ConfigSelection(self.sharetypelist, default=mounttype))
self.hdd_replacementConfigEntry = NoSave(ConfigYesNo(default=hdd_replacement))
def getAutoTimerSettingsDefinitions():
# TODO : read from setup.xml if posible
intervaltext = _("Poll Interval (in h)")
intervaldesc = _(
"This is the delay in hours that the AutoTimer will wait after a search to search the EPG again."
)
if getImageDistro() in ('openmips', 'openatv'):
intervaltext = _("Poll Interval (in mins)")
intervaldesc = _(
"This is the delay in minutes that the AutoTimer will wait after a search to search the EPG again."
)
return [
[
_("Poll automatically"), config.plugins.autotimer.autopoll,
"autopoll",
_("Unless this is enabled AutoTimer will NOT automatically look for events matching your AutoTimers but only when you leave the GUI with the green button."
)
],
[
_("Only poll while in standby"),
config.plugins.autotimer.onlyinstandby, "onlyinstandby",
_("When this is enabled AutoTimer will ONLY check for new events whilst in stanadby."
)
],
#TODO integrate this setting or let comment out
#[_("Delay after editing (in sec)"), config.plugins.autotimer.editdelay,"editdelay", _("This is the delay in seconds that the AutoTimer will wait after editing the AutoTimers.")],
[
_("Startup delay (in min)"), config.plugins.autotimer.delay,
"delay",
_("This is the delay in minutes that the AutoTimer will wait on initial launch to not delay enigma2 startup time."
)
],
#TODO back to hours
#[_("Poll Interval (in h)"), config.plugins.autotimer.interval,"interval", _("This is the delay in hours that the AutoTimer will wait after a search to search the EPG again.")],
#[_("Poll Interval (in mins)"), config.plugins.autotimer.interval,"interval", _("This is the delay in minutes that the AutoTimer will wait after a search to search the EPG again.")],
[
intervaltext, config.plugins.autotimer.interval, "interval",
intervaldesc
],
#TODO integrate this setting or let comment out
#[_("Timeout (in min)"), config.plugins.autotimer.timeout,"timeout", _("This is the duration in minutes that the AutoTimer is allowed to run.")],
[
_("Only add timer for next x days"),
config.plugins.autotimer.maxdaysinfuture, "maxdaysinfuture",
_("You can control for how many days in the future timers are added. Set this to 0 to disable this feature."
)
],
[
_("Show in plugin browser"),
config.plugins.autotimer.show_in_plugins, "show_in_plugins",
_("Enable this to be able to access the AutoTimer Overview from within the plugin browser."
)
],
[
_("Show in extension menu"),
config.plugins.autotimer.show_in_extensionsmenu,
"show_in_extensionsmenu",
_("Enable this to be able to access the AutoTimer Overview from within the extension menu."
)
],
[
_("Modify existing timers"), config.plugins.autotimer.refresh,
"refresh",
_("This setting controls the behavior when a timer matches a found event."
)
],
[
_("Guess existing timer based on begin/end"),
config.plugins.autotimer.try_guessing, "try_guessing",
_("If this is enabled an existing timer will also be considered recording an event if it records at least 80% of the it."
)
],
[
_("Add similar timer on conflict"),
config.plugins.autotimer.addsimilar_on_conflict,
"addsimilar_on_conflict",
_("If a timer conflict occurs, AutoTimer will search outside the timespan for a similar event and add it."
)
],
[
_("Add timer as disabled on conflict"),
config.plugins.autotimer.disabled_on_conflict,
"disabled_on_conflict",
_("This toggles the behavior on timer conflicts. If an AutoTimer matches an event that conflicts with an existing timer it will not ignore this event but add it disabled."
)
],
[
_("Include \"AutoTimer\" in tags"),
config.plugins.autotimer.add_autotimer_to_tags,
"add_autotimer_to_tags",
_("If this is selected, the tag \"AutoTimer\" will be given to timers created by this plugin."
)
],
[
_("Include AutoTimer name in tags"),
config.plugins.autotimer.add_name_to_tags, "add_name_to_tags",
_("If this is selected, the name of the respective AutoTimer will be added as a tag to timers created by this plugin."
)
],
[
_("Show notification on conflicts"),
config.plugins.autotimer.notifconflict, "notifconflict",
_("By enabling this you will be notified about timer conflicts found during automated polling. There is no intelligence involved, so it might bother you about the same conflict over and over."
)
],
[
_("Show notification on similars"),
config.plugins.autotimer.notifsimilar, "notifsimilar",
_("By enabling this you will be notified about similar timers added during automated polling. There is no intelligence involved, so it might bother you about the same conflict over and over."
)
],
[
_("Editor for new AutoTimers"), config.plugins.autotimer.editor,
"editor",
_("The editor to be used for new AutoTimers. This can either be the Wizard or the classic editor."
)
],
[
_("Support \"Fast Scan\"?"), config.plugins.autotimer.fastscan,
"fastscan",
_("When supporting \"Fast Scan\" the service type is ignored. You don't need to enable this unless your Image supports \"Fast Scan\" and you are using it."
)
],
[
_("Skip poll during records"),
config.plugins.autotimer.skip_during_records,
"skip_during_records",
_("If enabled, the polling will be skipped if a recording is in progress."
)
],
[
_("Skip poll during epg refresh"),
config.plugins.autotimer.skip_during_epgrefresh,
"skip_during_epgrefresh",
_("If enabled, the polling will be skipped if EPGRefresh is currently running."
)
],
[
_("Popup timeout in seconds"),
config.plugins.autotimer.popup_timeout, "popup_timeout",
_("If 0, the popup will remain open.")
],
[
_("Remove not existing events"),
config.plugins.autotimer.check_eit_and_remove,
"check_eit_and_remove",
_("Check the event id (eit) and remove the timer if there is no corresponding EPG event. Due to compatibility issues with SerienRecorder and IPRec, only timer created by AutoTimer are affected."
)
],
[
_("Always write config"),
config.plugins.autotimer.always_write_config,
"always_write_config",
_("Write the config file after every change which the user quits by saving."
)
]
]
def _(txt):
if gettext.dgettext(PluginLanguageDomain, txt):
return gettext.dgettext(PluginLanguageDomain, txt)
else:
print "[" + PluginLanguageDomain + "] fallback to default translation for " + txt
return gettext.gettext(txt)
language.addCallback(localeInit())
config.plugins.autotimer = ConfigSubsection()
config.plugins.autotimer.autopoll = ConfigEnableDisable(default=True)
config.plugins.autotimer.delay = ConfigNumber(default=3)
config.plugins.autotimer.editdelay = ConfigNumber(default=3)
default_unit = "hour"
if getImageDistro() in ('beyonwiz', 'teamblue', 'openatv', 'openvix', 'opendroid'): # distros that want default polling in minutes
default_unit = "minute"
config.plugins.autotimer.unit = ConfigSelection(choices=[
("hour", _("Hour")),
("minute", _("Minute"))
], default = default_unit
)
default_interval = {"hour": 4, "minute": 30} # default poll every 4 hours or 30 minutes
if getImageDistro() in ('teamblue', 'openatv'):
default_interval["minute"] = 240
config.plugins.autotimer.interval = ConfigNumber(default=default_interval[config.plugins.autotimer.unit.value])
config.plugins.autotimer.timeout = ConfigNumber(default=5)
config.plugins.autotimer.popup_timeout = ConfigNumber(default=5)
config.plugins.autotimer.check_eit_and_remove = ConfigYesNo(default=False)
def buildTimerEntry(self, timer, processed):
screenwidth = getDesktop(0).size().width()
height = self.l.getItemSize().height()
width = self.l.getItemSize().width()
res = [None]
x = (2 * width) // 3
if screenwidth and screenwidth == 1920:
res.append((eListboxPythonMultiContent.TYPE_TEXT, 50, 2, x - 24,
35, 3, RT_HALIGN_LEFT | RT_VALIGN_TOP, timer.name))
else:
res.append((eListboxPythonMultiContent.TYPE_TEXT, 26, 2, x - 24,
25, 1, RT_HALIGN_LEFT | RT_VALIGN_TOP, timer.name))
if getImageDistro() in ("easy-gui-aus", "beyonwiz"):
text = ("%s") % timer.service_ref.getServiceName()
else:
text = ("%s %s") % (timer.service_ref.getServiceName(),
self.getOrbitalPos(timer.service_ref))
if screenwidth and screenwidth == 1920:
res.append(
(eListboxPythonMultiContent.TYPE_TEXT, x, 0, width - x - 2, 35,
3, RT_HALIGN_RIGHT | RT_VALIGN_TOP, text))
else:
res.append(
(eListboxPythonMultiContent.TYPE_TEXT, x, 0, width - x - 2, 25,
0, RT_HALIGN_RIGHT | RT_VALIGN_TOP, text))
days = (_("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"),
_("Sun"))
begin = FuzzyTime(timer.begin)
if timer.repeated:
repeatedtext = []
flags = timer.repeated
for x in (0, 1, 2, 3, 4, 5, 6):
if flags & 1 == 1:
repeatedtext.append(days[x])
flags >>= 1
repeatedtext = ", ".join(repeatedtext)
if self.iconRepeat:
if screenwidth and screenwidth == 1920:
res.append(
(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND, 5,
3, 30, 30, self.iconRepeat))
else:
res.append(
(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND, 2,
2, 20, 20, self.iconRepeat))
else:
repeatedtext = begin[0] # date
if timer.justplay:
text = repeatedtext + ((" %s " + _("(ZAP)")) % (begin[1]))
else:
text = repeatedtext + ((" %s ... %s (%d " + _("mins") + ")") %
(begin[1], FuzzyTime(timer.end)[1],
(timer.end - timer.begin) / 60))
if screenwidth and screenwidth == 1920:
res.append(
(eListboxPythonMultiContent.TYPE_TEXT, 148, 37, width - 150,
35, 3, RT_HALIGN_RIGHT | RT_VALIGN_BOTTOM, text))
else:
res.append(
(eListboxPythonMultiContent.TYPE_TEXT, 148, 24, width - 150,
25, 1, RT_HALIGN_RIGHT | RT_VALIGN_BOTTOM, text))
icon = None
if not processed:
if timer.state == TimerEntry.StateWaiting:
state = _("waiting")
icon = self.iconWait
elif timer.state == TimerEntry.StatePrepared:
state = _("about to start")
icon = self.iconPrepared
elif timer.state == TimerEntry.StateRunning:
if timer.justplay:
state = _("zapped")
icon = self.iconZapped
else:
state = _("recording...")
icon = self.iconRecording
elif timer.state == TimerEntry.StateEnded:
state = _("done!")
icon = self.iconDone
else:
state = _("<unknown>")
icon = None
else:
state = _("done!")
icon = self.iconDone
if timer.disabled:
state = _("disabled")
icon = self.iconDisabled
if timer.failed:
state = _("failed")
icon = self.iconFailed
if screenwidth and screenwidth == 1920:
res.append((eListboxPythonMultiContent.TYPE_TEXT, 50, 40, 150, 35,
3, RT_HALIGN_LEFT | RT_VALIGN_TOP, state))
else:
res.append((eListboxPythonMultiContent.TYPE_TEXT, 26, 24, 90, 20,
1, RT_HALIGN_LEFT | RT_VALIGN_TOP, state))
if icon:
if screenwidth and screenwidth == 1920:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
5, 40, 30, 30, icon))
else:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
2, 25, 20, 20, icon))
if timer.isAutoTimer:
if screenwidth and screenwidth == 1920:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
5, 3, 30, 30, self.iconAutoTimer))
else:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
2, 2, 20, 20, self.iconAutoTimer))
elif timer.ice_timer_id is not None:
if screenwidth and screenwidth == 1920:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
5, 3, 30, 30, self.iconIceTVTimer))
else:
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND,
2, 2, 20, 20, self.iconIceTVTimer))
line = LoadPixmap(resolveFilename(SCOPE_ACTIVE_SKIN, "div-h.png"))
res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHABLEND, 0,
height - 2, width, 2, line))
return res
def _(txt):
if gettext.dgettext(PluginLanguageDomain, txt):
return gettext.dgettext(PluginLanguageDomain, txt)
else:
print("[" + PluginLanguageDomain +
"] fallback to default translation for " + txt)
return gettext.gettext(txt)
language.addCallback(localeInit())
config.plugins.epgsearch = ConfigSubsection()
config.plugins.epgsearch.showinplugins = ConfigYesNo(default=False)
__searchDefaultScope = "currentbouquet" if getImageDistro() in (
"easy-gui-aus", "beyonwiz") else "all"
config.plugins.epgsearch.scope = ConfigSelection(choices=[
("all", _("all services")), ("allbouquets", _("all bouquets")),
("currentbouquet", _("current bouquet")),
("currentservice", _("current service")), ("ask", _("ask user"))
],
default=__searchDefaultScope)
config.plugins.epgsearch.defaultscope = ConfigSelection(
choices=[("all", _("all services")), ("allbouquets", _("all bouquets")),
("currentbouquet", _("current bouquet")),
("currentservice", _("current service"))],
default=__searchDefaultScope)
config.plugins.epgsearch.search_type = ConfigSelection(
default="partial",
choices=[("partial", _("partial match")),
def getInfo():
# TODO: get webif versione somewhere!
info = {}
info['brand'] = getMachineBrand()
info['model'] = getMachineName()
chipset = "unknown"
if fileExists("/proc/stb/info/azmodel"):
brand = "AZBOX"
file = open("/proc/stb/info/model")
model = file.read().strip().lower()
file.close()
if model == "me":
chipset = "SIGMA 8655"
elif model == "minime":
chipset = "SIGMA 8653"
else:
chipset = "SIGMA 8634"
if fileExists("/proc/stb/info/chipset"):
f = open("/proc/stb/info/chipset", 'r')
chipset = f.readline().strip()
f.close()
info['chipset'] = chipset
memFree = 0
file = open("/proc/meminfo", 'r')
for line in file:
parts = line.split(':')
key = parts[0].strip()
if key == "MemTotal":
info['mem1'] = parts[1].strip()
elif key in ("MemFree", "Buffers", "Cached"):
memFree += int(parts[1].strip().split(' ', 1)[0])
info['mem2'] = "%s kB" % memFree
file.close()
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['oever'] = getOEVersion()
info['imagever'] = getImageVersion() + '.' + getImageBuild()
info['enigmaver'] = getEnigmaVersionString()
info['driverdate'] = getDriverDate()
info['kernelver'] = about.getKernelVersionString()
try:
from Tools.StbHardware import getFPVersion
except ImportError:
from Tools.DreamboxHardware import getFPVersion
info['fp_version'] = getFPVersion()
info['tuners'] = []
for i in range(0, nimmanager.getSlotCount()):
info['tuners'].append({
"name":
nimmanager.getNim(i).getSlotName(),
"type":
nimmanager.getNimName(i) + " (" +
nimmanager.getNim(i).getFriendlyType() + ")"
})
info['ifaces'] = []
ifaces = iNetwork.getConfiguredAdapters()
for iface in ifaces:
info['ifaces'].append({
"name":
iNetwork.getAdapterName(iface),
"mac":
iNetwork.getAdapterAttribute(iface, "mac"),
"dhcp":
iNetwork.getAdapterAttribute(iface, "dhcp"),
"ip":
formatIp(iNetwork.getAdapterAttribute(iface, "ip")),
"mask":
formatIp(iNetwork.getAdapterAttribute(iface, "netmask")),
"gw":
formatIp(iNetwork.getAdapterAttribute(iface, "gateway")),
"ipv6":
getAdapterIPv6(iface)
})
info['hdd'] = []
for hdd in harddiskmanager.hdd:
if hdd.free() <= 1024:
free = "%i MB" % (hdd.free())
else:
free = float(hdd.free()) / float(1024)
free = "%.3f GB" % free
info['hdd'].append({
"model": hdd.model(),
"capacity": hdd.capacity(),
"free": free
})
return info
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"
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 = int((stat.f_bfree / 1024) * (stat.f_bsize / 1024))
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
if (info['model'] in ("Uno4K", "Ultimo4K", "Solo4K", "Solo²", "Duo²",
"Solo SE", "Quad", "Quad Plus")
or info['machinebuild']
in ('inihdp', 'hd2400', 'et10000', 'xpeedlx3', 'ew7356',
'dags7356', 'dags7252', 'formuler1tc')):
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']
for l in lang:
if l in language.getLanguage():
info['kinopoisk'] = True
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 getInfo():
# TODO: get webif versione somewhere!
info = {}
info['brand'] = getMachineBrand()
info['model'] = getMachineName()
info['boxtype'] = getBoxType()
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"
else:
f = open("/proc/stb/info/model",'r')
model = f.readline().strip().lower()
f.close()
if model in ("esi88", "sagemcom88", "nbox"):
if fileExists("/proc/boxtype"):
f = open("/proc/boxtype",'r')
model = f.readline().strip().lower()
f.close()
if model == "tf7700hdpvr":
chipset = "SH4 @266MHz"
elif model in ("nbox", "bska", "bsla", "bxzb", "bzzb"):
chipset = "SH4 @266MHz"
elif model in ("adb2850", "adb2849"):
chipset = "SH4 @450MHz"
elif model in ("sagemcom88", "esi88", "uhd88", "dsi87"):
chipset = "SH4 @450MHz"
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()
elif key in ("MemFree", "Buffers", "Cached"):
memFree += int(parts[1].strip().split(' ',1)[0])
info['mem2'] = "%s kB" % memFree
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['oever'] = getOEVersion()
info['imagever'] = getImageVersion() + '.' + getImageBuild()
info['enigmaver'] = getEnigmaVersionString()
info['driverdate'] = getDriverDate()
info['kernelver'] = about.getKernelVersionString()
try:
from Tools.StbHardware import getFPVersion
except ImportError:
from Tools.DreamboxHardware import getFPVersion
info['fp_version'] = getFPVersion()
info['tuners'] = []
for i in range(0, nimmanager.getSlotCount()):
info['tuners'].append({
"name": nimmanager.getNim(i).getSlotName(),
"type": nimmanager.getNimName(i) + " (" + nimmanager.getNim(i).getFriendlyType() + ")"
})
info['ifaces'] = []
ifaces = iNetwork.getConfiguredAdapters()
for iface in ifaces:
info['ifaces'].append({
"name": iNetwork.getAdapterName(iface),
"mac": iNetwork.getAdapterAttribute(iface, "mac"),
"dhcp": iNetwork.getAdapterAttribute(iface, "dhcp"),
"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)
})
info['hdd'] = []
for hdd in harddiskmanager.hdd:
dev = hdd.findMount()
if dev:
stat = os.statvfs(dev)
free = int((stat.f_bfree/1024) * (stat.f_bsize/1024))
else:
free = -1
if free <= 1024:
free = "%i MB" % free
else:
free = float(free) / float(1024)
free = "%.3f GB" % free
size = hdd.diskSize() * 1000000 / float(1048576)
if size > 1048576:
size = "%.2f TB" % (size / float(1048576))
elif size > 1024:
size = "%d GB" % (size / float(1024))
else:
size = "%d MB" % size
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 TB" % iecsize
else:
iecsize = "%d TB" % iecsize
# Round harddisk sizes beyond ~300GB to full tens: 320, 500, 640, 750GB
elif iecsize > 300000:
iecsize = "%d GB" % ((iecsize + 5000) // 10000 * 10)
# ... be more precise for media < ~300GB (Sticks, SSDs, CF, MMC, ...): 1, 2, 4, 8, 16 ... 256GB
elif iecsize > 1000:
iecsize = "%d GB" % ((iecsize + 500) // 1000)
else:
iecsize = "%d MB" % iecsize
info['hdd'].append({
"model": hdd.model(),
"capacity": size,
"labelled_capacity": iecsize,
"free": free
})
global STATICBOXINFO
STATICBOXINFO = info
return info
def getFriendlyImageDistro():
dist = getImageDistro().replace("openatv", "OpenATV").replace(
"openhdf", "OpenHDF").replace("openpli",
"OpenPLi").replace("openvix", "OpenViX")
return dist
openatv_like = True
try:
# This works in OpenATV (and similar code bases) but fails on OpenPLi.
# The particular import might not be relevant for the actual plugin.
from Screens.EpgSelection import SingleEPG
ADJUST = {'adjust': False}
except:
ADJUST = {}
openatv_like = False
# Quick fix for Vix
try:
import boxbranding
if "openvix" in boxbranding.getImageDistro().lower():
openatv_like = True
except:
pass
SESSION = None
import os
import threading
import traceback
from enigma import eTimer
from Components.config import config, ConfigBoolean, ConfigNumber, ConfigSelection, ConfigSubsection, ConfigText
from Plugins.Plugin import PluginDescriptor
if openatv_like:
from Screens.Setup import Setup
else:
import Screens.Setup
from Components.config import getConfigListEntry, configfile, ConfigSelection, ConfigSubsection, ConfigText, ConfigLocations
from Components.config import config
from Components.ConfigList import ConfigList,ConfigListScreen
from Components.FileList import MultiFileSelectList
from Components.Network import iNetwork
from Plugins.Plugin import PluginDescriptor
from enigma import eTimer, eEnv, eConsoleAppContainer, eEPGCache
from Tools.Directories import *
from os import system, popen, path, makedirs, listdir, access, stat, rename, remove, W_OK, R_OK
from time import gmtime, strftime, localtime, sleep
from datetime import date
from boxbranding import getBoxType, getMachineBrand, getMachineName, getImageDistro
import ShellCompatibleFunctions
boxtype = getBoxType()
distro = getImageDistro()
def eEnv_resolve_multi(path):
resolve = eEnv.resolve(path)
return resolve.split()
config.plugins.configurationbackup = ConfigSubsection()
if boxtype in ('maram9', 'classm', 'axodin', 'axodinc', 'starsatlx', 'genius', 'evo', 'galaxym6') and not path.exists("/media/hdd/backup_%s" %boxtype):
config.plugins.configurationbackup.backuplocation = ConfigText(default = '/media/backup/', visible_width = 50, fixed_size = False)
else:
config.plugins.configurationbackup.backuplocation = ConfigText(default = '/media/hdd/', visible_width = 50, fixed_size = False)
config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/CCcam.cfg', '/usr/keys/',
'/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf',
'/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname',
eEnv.resolve("${datadir}/enigma2/keymap.usr")])
#!/usr/bin/python
# epgdat.py by Ambrosa http://www.dreamboxonline.com
# Heavily modified by MiLo http://www.sat4all.com/
# Lots of stuff removed that i did not need.
import os
import sys
import codecs
import struct
from datetime import datetime
from boxbranding import getImageDistro
EpgDatV8 = getImageDistro() in ("openvix",)
try:
import dreamcrc
crc32_dreambox = lambda d, t: dreamcrc.crc32(d, t) & 0xffffffff
print "[EPGImport] using C module, yay"
except:
print "[EPGImport] failed to load C implementation, sorry"
# this table is used by CRC32 routine below (used by Dreambox for
# computing REF DESC value).
# The original DM routine is a modified CRC32 standard routine,
# so cannot use Python standard binascii.crc32()
CRCTABLE = (
0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9,
0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9,
class AutoBouquetsMaker_ProvidersSetup(ConfigListScreen, Screen):
# Note to skinners: no need to skin this screen if you have skinned the screen 'AutoBouquetsMaker_Setup'.
skin = skin_setup()
ABM_BOUQUET_PREFIX = "userbouquet.abm."
try: # Work-around to get OpenSPA working
from boxbranding import getImageDistro
if getImageDistro() == 'openspa':
def keyLeft(self):
ConfigListScreen.keyLeft(self)
self.changedEntry()
def keyRight(self):
ConfigListScreen.keyRight(self)
self.changedEntry()
except:
pass
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.skinName = "AutoBouquetsMaker_Setup"
self.setup_title = _("AutoBouquetsMaker Providers")
Screen.setTitle(self, self.setup_title)
self.onChangedEntry = [ ]
self.list = []
ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry)
self.activityTimer = eTimer()
self.activityTimer.timeout.get().append(self.prepare)
self["actions"] = ActionMap(["SetupActions", 'ColorActions', 'VirtualKeyboardActions', "MenuActions"],
{
"ok": self.keySave,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keySave,
"menu": self.keyCancel,
}, -2)
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("Save"))
self["pleasewait"] = Label()
self["description"] = Label("")
self.onLayoutFinish.append(self.populate)
def populate(self):
self["actions"].setEnabled(False)
self["pleasewait"].setText(_("Please wait..."))
self.activityTimer.start(1)
def prepare(self):
self.activityTimer.stop()
self.providers = Manager().getProviders()
self.providers_configs = {}
self.providers_area = {}
self.providers_swapchannels = {}
self.providers_makemain = {}
self.providers_custommain = {}
self.providers_makesections = {}
self.providers_makehd = {}
self.providers_makefta = {}
self.providers_makeftahd = {}
self.providers_FTA_only = {}
self.providers_order = []
self.orbital_supported = []
# get supported orbital positions
dvbs_nims = nimmanager.getNimListOfType("DVB-S")
for nim in dvbs_nims:
sats = nimmanager.getSatListForNim(nim)
for sat in sats:
if sat[0] not in self.orbital_supported:
self.orbital_supported.append(sat[0])
self.dvbc_nims = []
self.dvbt_nims = []
try: # OpenPLi Hot Switch compatible image
for nim in nimmanager.nim_slots:
if nim.config_mode != "nothing":
if "DVB-C" in [x[:5] for x in nim.getTunerTypesEnabled()]:
self.dvbc_nims.append(nim.slot)
if "DVB-T" in [x[:5] for x in nim.getTunerTypesEnabled()]:
self.dvbt_nims.append(nim.slot)
except AttributeError:
try:
for nim in nimmanager.nim_slots:
if nim.config_mode != "nothing":
if nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")):
self.dvbc_nims.append(nim.slot)
if nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T")):
self.dvbt_nims.append(nim.slot)
except AttributeError: # OpenATV > 5.3
for nim in nimmanager.nim_slots:
if nim.canBeCompatible("DVB-C") and nim.config_mode_dvbc != "nothing":
self.dvbc_nims.append(nim.slot)
if nim.canBeCompatible("DVB-T") and nim.config_mode_dvbt != "nothing":
self.dvbt_nims.append(nim.slot)
# dependent providers
self.dependents_list = []
for provider_key in self.providers:
if len(self.providers[provider_key]["dependent"]) > 0 and self.providers[provider_key]["dependent"] in self.providers:
self.dependents_list.append(provider_key)
# read providers configurations
providers_tmp_configs = {}
providers_tmp = config.autobouquetsmaker.providers.value.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
if not provider_config.isValid():
continue
if provider_config.getProvider() not in self.providers:
continue
if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbs' and self.providers[provider_config.getProvider()]["transponder"]["orbital_position"] not in self.orbital_supported:
continue
if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbc' and len(self.dvbc_nims) <= 0:
continue
if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbt' and len(self.dvbt_nims) <= 0:
continue
self.providers_order.append(provider_config.getProvider())
providers_tmp_configs[provider_config.getProvider()] = provider_config
# get current bouquets list (for custom main)
bouquets = Manager().getBouquetsList()
bouquets_list = []
if bouquets["tv"] is not None:
for bouquet in bouquets["tv"]:
if bouquet["filename"][:len(self.ABM_BOUQUET_PREFIX)] == self.ABM_BOUQUET_PREFIX:
continue
bouquets_list.append((bouquet["filename"], bouquet["name"]))
# build providers configurations
for provider in list(self.providers.keys()):
self.providers_configs[provider] = ConfigYesNo(default = (provider not in self.dependents_list and provider in list(providers_tmp_configs.keys())))
self.providers_swapchannels[provider] = ConfigYesNo(default = (provider in providers_tmp_configs and providers_tmp_configs[provider].isSwapChannels()))
custom_bouquets_exists = False
self.providers_makemain[provider] = None
self.providers_custommain[provider] = None
self.providers_makesections[provider] = None
self.providers_makehd[provider] = None
self.providers_makefta[provider] = None
self.providers_makeftahd[provider] = None
if len(list(self.providers[provider]["sections"].keys())) > 1: # only if there's more than one section
sections_default = True
if provider in providers_tmp_configs:
sections_default = providers_tmp_configs[provider].isMakeSections()
self.providers_makesections[provider] = ConfigYesNo(default = sections_default)
custom_bouquets_exists = True
if self.providers[provider]["protocol"] != "fastscan": # fastscan doesn't have enough information to make HD and/or FTA bouquets
hd_default = True
fta_default = True
ftahd_default = True
if provider in providers_tmp_configs:
hd_default = providers_tmp_configs[provider].isMakeHD()
fta_default = providers_tmp_configs[provider].isMakeFTA()
ftahd_default = providers_tmp_configs[provider].isMakeFTAHD()
self.providers_makehd[provider] = ConfigYesNo(default = hd_default)
self.providers_makefta[provider] = ConfigYesNo(default = fta_default)
self.providers_makeftahd[provider] = ConfigYesNo(default = ftahd_default)
custom_bouquets_exists = True
if sorted(list(self.providers[provider]["sections"].keys()))[0] > 1:
makemain_default = "no"
makemain_list = [("yes", _("yes (all channels)"))]
if self.providers[provider]["protocol"] != "fastscan":
makemain_list.append(("hd", _("yes (only HD)")))
makemain_list.append(("ftahd", _("yes (only FTA HD)")))
if provider not in providers_tmp_configs and self.providers[provider]["protocol"] == "sky":
makemain_default = "ftahd" # First bouquet option starts as "FTA HD"
elif provider not in providers_tmp_configs and self.providers[provider]["protocol"] in ("vmuk", "vmuk2"):
makemain_default = "hd" # First bouquet option starts as "HD"
elif provider not in providers_tmp_configs:
makemain_default = "yes" # First bouquet option starts as "All channels"
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain():
makemain_default = "yes"
if self.providers[provider]["protocol"] != "fastscan":
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeHDMain():
makemain_default = "hd"
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeFTAHDMain():
makemain_default = "ftahd"
if len(bouquets_list) > 0 and config.autobouquetsmaker.placement.getValue() == 'top':
makemain_list.append(("custom", _("yes (custom)")))
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeCustomMain():
makemain_default = "custom"
bouquet_default = bouquets_list[0][0]
if provider in providers_tmp_configs:
for bouquet_entry in bouquets_list:
if bouquet_entry[0] == providers_tmp_configs[provider].getCustomFilename():
bouquet_default = bouquet_entry[0]
break
self.providers_custommain[provider] = ConfigSelection(default = bouquet_default, choices = bouquets_list)
makemain_list.append(("no", _("no")))
self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = makemain_list)
elif custom_bouquets_exists:
makemain_default = "no"
if provider not in providers_tmp_configs:
makemain_default = "yes"
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain():
makemain_default = "yes"
self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = [("yes", _("yes")), ("no", _("no"))])
arealist = []
bouquets = self.providers[provider]["bouquets"]
for bouquet in list(bouquets.keys()):
arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"]))
arealist.sort(key=lambda x: x[1])
if len(self.providers[provider]["bouquets"]) > 0: # provider has area list
default_area = None
if provider in providers_tmp_configs:
default_area = providers_tmp_configs[provider].getArea()
self.providers_area[provider] = ConfigSelection(default = default_area, choices = arealist)
# FTA only
FTA_only = config.autobouquetsmaker.FTA_only.value.split("|")
FTA = self.providers[provider]["protocol"] != "fastscan" and config.autobouquetsmaker.level.value == "expert" and provider in FTA_only
self.providers_FTA_only[provider] = ConfigYesNo(default = FTA)
self.createSetup()
self["pleasewait"].hide()
self["actions"].setEnabled(True)
def providerKeysInNameOrder(self, providers):
temp = []
for provider in list(providers.keys()):
temp.append((provider, providers[provider]["name"]))
if six.PY2:
return [i[0] for i in sorted(temp, key=lambda p: p[1].lower().decode('ascii','ignore'))]
return [i[0] for i in sorted(temp, key=lambda p: six.ensure_binary(p[1]).lower().decode('ascii','ignore'))]
def createSetup(self):
self.editListEntry = None
self.list = []
providers_enabled = []
providers_already_loaded = []
indent = '- '
for provider in self.providerKeysInNameOrder(self.providers):
if provider in self.dependents_list:
continue
if self.providers[provider]["streamtype"] == 'dvbs' and self.providers[provider]["transponder"]["orbital_position"] not in self.orbital_supported:
continue
if self.providers[provider]["streamtype"] == 'dvbc' and len(self.dvbc_nims) <= 0:
continue
if self.providers[provider]["streamtype"] == 'dvbt' and len(self.dvbt_nims) <= 0:
continue
if self.providers[provider]["name"] in providers_already_loaded:
continue
else:
providers_already_loaded.append(self.providers[provider]["name"])
self.list.append(getConfigListEntry(self.providers[provider]["name"], self.providers_configs[provider], _("This option enables the current selected provider.")))
if self.providers_configs[provider].value:
if len(self.providers[provider]["bouquets"]) > 0:
self.list.append(getConfigListEntry(indent + _("Region"), self.providers_area[provider], _("This option allows you to choose what region of the country you live in, so it populates the correct channels for your region.")))
if config.autobouquetsmaker.level.value == "expert":
# fta only
if self.providers[provider]["protocol"] != "fastscan":
self.list.append(getConfigListEntry(indent + _("FTA only"), self.providers_FTA_only[provider], _("This affects all bouquets. Select 'no' to scan in all services. Select 'yes' to skip encrypted ones.")))
if self.providers_makemain[provider]:
self.list.append(getConfigListEntry(indent + _("Create main bouquet"), self.providers_makemain[provider], _('This option has several choices "Yes", (create a bouquet with all the channels in it), "Yes HD only", (will group all HD channels into this bouquet), "Custom", (allows you to select your own bouquet), "No", (do not use a main bouquet)')))
if self.providers_custommain[provider] and self.providers_makemain[provider] and self.providers_makemain[provider].value == "custom":
self.list.append(getConfigListEntry(indent + _("Custom bouquet for main"), self.providers_custommain[provider], _("Select your own bouquet from the list, please note that the only the first 100 channels for this bouquet will be used.")))
if self.providers_makesections[provider]:
self.list.append(getConfigListEntry(indent + _("Create sections bouquets"), self.providers_makesections[provider], _("This option will create bouquets for each type of channel, ie Entertainment, Movies, Documentary.")))
if self.providers_makehd[provider] and (self.providers_makemain[provider] is None or self.providers_makemain[provider].value != "hd"):
self.list.append(getConfigListEntry(indent + _("Create HD bouquet"), self.providers_makehd[provider], _("This option will create a High Definition bouquet, it will group all HD channels into this bouquet.")))
if self.providers_makefta[provider] and not self.providers_FTA_only[provider].value:
self.list.append(getConfigListEntry(indent + _("Create FTA bouquet"), self.providers_makefta[provider], _("This option will create a FreeToAir bouquet, it will group all free channels into this bouquet.")))
if self.providers_makeftahd[provider] and (self.providers_makemain[provider] is None or self.providers_makemain[provider].value != "ftahd") and not self.providers_FTA_only[provider].value:
self.list.append(getConfigListEntry(indent + _("Create FTA HD bouquet"), self.providers_makeftahd[provider], _("This option will create a FreeToAir High Definition bouquet, it will group all FTA HD channels into this bouquet.")))
if ((self.providers_makemain[provider] and self.providers_makemain[provider].value == "yes") or (self.providers_makesections[provider] and self.providers_makesections[provider].value == True)) and len(self.providers[provider]["swapchannels"]) > 0:
self.list.append(getConfigListEntry(indent + _("Swap channels"), self.providers_swapchannels[provider], _("This option will swap SD versions of channels with HD versions. (eg BBC One SD with BBC One HD, Channel Four SD with with Channel Four HD)")))
providers_enabled.append(provider)
for provider in providers_enabled:
if provider not in self.providers_order:
self.providers_order.append(provider)
for provider in self.providers_order:
if provider not in providers_enabled:
self.providers_order.remove(provider)
self["config"].list = self.list
self["config"].setList(self.list)
# for summary:
def changedEntry(self):
self.item = self["config"].getCurrent()
for x in self.onChangedEntry:
x()
try:
if isinstance(self["config"].getCurrent()[1], ConfigYesNo) or isinstance(self["config"].getCurrent()[1], ConfigSelection):
self.createSetup()
except:
pass
def getCurrentEntry(self):
return self["config"].getCurrent() and str(self["config"].getCurrent()[0]) or ""
def getCurrentValue(self):
return self["config"].getCurrent() and str(self["config"].getCurrent()[1].getText()) or ""
def getCurrentDescription(self):
return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or ""
def createSummary(self):
return SetupSummary
def saveAll(self):
for x in self["config"].list:
x[1].save()
FTA_only = []
config_string = ""
for provider in self.providers_order:
if self.providers_configs[provider].value:
if len(config_string) > 0:
config_string += "|"
provider_config = ProviderConfig()
provider_config.unsetAllFlags()
provider_config.setProvider(provider)
if len(self.providers[provider]["bouquets"]) > 0:
provider_config.setArea(self.providers_area[provider].value)
if self.providers_makemain[provider] is None or self.providers_makemain[provider].value == "yes":
provider_config.setMakeNormalMain()
elif self.providers_makemain[provider].value == "hd":
provider_config.setMakeHDMain()
elif self.providers_makemain[provider].value == "ftahd":
provider_config.setMakeFTAHDMain()
elif self.providers_makemain[provider].value == "custom":
provider_config.setMakeCustomMain()
provider_config.setCustomFilename(self.providers_custommain[provider].value)
if self.providers_makesections[provider] and self.providers_makesections[provider].value:
provider_config.setMakeSections()
if self.providers_makehd[provider] and self.providers_makehd[provider].value and (self.providers_makemain[provider] is None or self.providers_makemain[provider].value != "hd"):
provider_config.setMakeHD()
if self.providers_makefta[provider] and self.providers_makefta[provider].value and not self.providers_FTA_only[provider].value:
provider_config.setMakeFTA()
if self.providers_makeftahd[provider] and self.providers_makeftahd[provider].value and (self.providers_makemain[provider] is None or self.providers_makemain[provider].value != "ftahd") and not self.providers_FTA_only[provider].value:
provider_config.setMakeFTAHD()
if self.providers_swapchannels[provider] and self.providers_swapchannels[provider].value:
provider_config.setSwapChannels()
config_string += provider_config.serialize()
if self.providers_FTA_only[provider].value:
FTA_only.append(provider)
# fta only
config.autobouquetsmaker.FTA_only.value = ''
if FTA_only:
config.autobouquetsmaker.FTA_only.value = '|'.join(FTA_only)
config.autobouquetsmaker.FTA_only.save()
config.autobouquetsmaker.providers.value = config_string
config.autobouquetsmaker.providers.save()
configfile.save()
# keySave and keyCancel are just provided in case you need them.
# you have to call them by yourself.
def keySave(self):
self.saveAll()
self.close()
def cancelConfirm(self, result):
if not result:
return
for x in self["config"].list:
x[1].cancel()
self.close()
def keyCancel(self):
if self["config"].isChanged():
self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
else:
self.close()
from Screens.Screen import Screen
from Components.Sources.StaticText import StaticText
from Components.SystemInfo import SystemInfo
from Components.Label import Label
from Components.ActionMap import ActionMap
from Components.About import about
from Components import Harddisk
from Screens.Console import Console
from Screens.MessageBox import MessageBox
from time import time, strftime, localtime
from os import path, system, makedirs, listdir, walk, statvfs, remove
import commands
import datetime
from boxbranding import getBoxType, getMachineBrand, getMachineName, getDriverDate, getImageVersion, getImageBuild, getBrandOEM, getMachineBuild, getImageFolder, getMachineUBINIZE, getMachineMKUBIFS, getMachineMtdKernel, getMachineMtdRoot, getMachineKernelFile, getMachineRootFile, getImageFileSystem, getImageDistro
VERSION = _('Version') + ' %s %s images' % (getImageVersion(), getImageDistro())
HaveGZkernel = True
if getMachineBuild() in ('ustym4kpro','hd60','i55plus','osmio4k','sf8008','cc1','dags72604', 'u51','u52','u53','h9','vuzero4k','u5','u5pvr','sf5008','et13000','et1x000',"vuuno4k","vuuno4kse", "vuultimo4k", "vusolo4k", "spark", "spark7162", "hd51", "hd52", "sf4008", "dags7252", "gb7252", "vs1500","h7",'xc7439','8100s'):
HaveGZkernel = False
def Freespace(dev):
statdev = statvfs(dev)
space = (statdev.f_bavail * statdev.f_frsize) / 1024
print "[FULL BACKUP] Free space on %s = %i kilobytes" %(dev, space)
return space
class ImageBackup(Screen):
skin = """
<screen position="center,center" size="560,400" title="Image Backup">
<ePixmap position="0,360" zPosition="1" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" />
if gettext.dgettext(PluginLanguageDomain, txt):
return gettext.dgettext(PluginLanguageDomain, txt)
else:
print "[" + PluginLanguageDomain + "] fallback to default translation for " + txt
return gettext.gettext(txt)
language.addCallback(localeInit())
config.plugins.autotimer = ConfigSubsection()
config.plugins.autotimer.autopoll = ConfigEnableDisable(default=True)
config.plugins.autotimer.delay = ConfigNumber(default=3)
config.plugins.autotimer.editdelay = ConfigNumber(default=3)
default_unit = "hour"
if getImageDistro() in (
'beyonwiz', 'teamblue', 'openatv',
'openvix'): # distros that want default polling in minutes
default_unit = "minute"
config.plugins.autotimer.unit = ConfigSelection(choices=[("hour", _("Hour")),
("minute",
_("Minute"))],
default=default_unit)
default_interval = {
"hour": 4,
"minute": 30
} # default poll every 4 hours or 30 minutes
if getImageDistro() in ('teamblue', 'openatv'):
default_interval["minute"] = 240
config.plugins.autotimer.interval = ConfigNumber(
