def __init__(self, isAutostart, session, args=0):
Screen.__init__(self, session)
self.session = session
self.Console = Console()
self.current_service = self.session.nav.getCurrentlyPlayingServiceReference(
)
selectable_nims = []
for nim in nimmanager.nim_slots:
if nim.config_mode == 'nothing':
continue
if nim.config_mode == 'advanced' and len(
nimmanager.getSatListForNim(nim.slot)) < 1:
continue
if nim.config_mode in ('loopthrough', 'satposdepends'):
root_id = nimmanager.sec.getRoot(
nim.slot_id, int(nim.config.connectedTo.value))
if nim.type == nimmanager.nim_slots[root_id].type:
continue
if nim.isCompatible('DVB-S'):
selectable_nims.append(
(str(nim.slot), nim.friendly_full_description))
self.select_nim = ConfigSelection(choices=selectable_nims)
self.feid = 0
if self.select_nim.value != '':
self.feid = int(self.select_nim.value)
self.frontend = self.OpenFrontend()
if self.frontend is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if not self.frontend:
if session.pipshown:
session.pipshown = False
del session.pip
if not self.openFrontend():
self.frontend = None
self.session.nav.playService(None)
self.switchmode = 0
self.showhide = 0
self['menu'] = List([])
self['actions'] = NumberActionMap(
['MediaPlayerActions', 'SetupActions', 'DirectionActions'], {
'menu': self.Konfig,
'ok': self.ok,
'cancel': self.sakri,
'up': self.keyUp,
'down': self.keyDown,
'left': self.keyLeft,
'right': self.keyRight,
'nextBouquet': self.ZapUp,
'prevBouquet': self.ZapDown,
'1': self.keyNumberGlobal,
'2': self.keyNumberGlobal,
'3': self.keyNumberGlobal,
'4': self.keyNumberGlobal,
'5': self.keyNumberGlobal,
'6': self.keyNumberGlobal,
'7': self.keyNumberGlobal,
'8': self.keyNumberGlobal,
'9': self.keyNumberGlobal,
'0': self.keyNumberGlobal
}, -2)
self['text2'] = Label(_('Loading...Please Wait'))
self['start_progress'] = ProgressBar()
self['infoM0'] = Label()
self['infoM1'] = Label()
self['infoM2'] = Label()
self['l001'] = Pixmap()
self['l002'] = Pixmap()
self['l003'] = Pixmap()
self['l004'] = Pixmap()
self['l005'] = Pixmap()
self['l006'] = Pixmap()
self['l007'] = Pixmap()
self['l008'] = Pixmap()
self['picon'] = Pixmap()
self.TestCounter = 0
self.playstarted = False
self.DVBCATimer = eTimer()
self.DVBCATimer.callback.append(self.Prepare)
buffersize = 512
try:
myfile = file(
'/usr/lib/enigma2/python/Plugins/Extensions/AzIPTV/config')
for line in myfile.readlines():
if line[0:1] != '#':
ipos = ipos1 = 0
ipos = line.find('<buffersize>')
ipos1 = line.find('</buffersize>')
if ipos != '' and ipos1 != '' and ipos1 > ipos:
buffersize = int(line[ipos + 12:ipos1])
except:
print 'Error reading cfg file.'
if buffersize < 128:
buffersize = 128
hw_type = HardwareInfo().get_device_name()
if hw_type == 'minime' or hw_type == 'me':
self.cmd0 = 'rmfp_player -dram 0 -ve 0 -vd 0 -ae 0 -no_disp -prebuf '
if hw_type == 'elite' or hw_type == 'premium' or hw_type == 'premium+' or hw_type == 'ultra':
self.cmd0 = 'rmfp_player -dram 1 -ve 1 -vd 0 -ae 0 -no_disp -prebuf '
self.cmd0 = self.cmd0 + str(
buffersize
) + ' -detect_limit 100 -resetvcxo -no_close -oscaler spu -nosubs '
self.showhide = 0
self['menu1'] = MenuList([])
self['menu'] = List([])
self.onLayoutFinish.append(self.startup)
def closE(self):
if self.jump_on_close == True:
self.session.nav.stopService()
self.session.nav.shutdown()
Console().ePopen('/bin/bh_jump')
def EnableSwapFile(self, result, retval, extra_args):
Console().ePopen("swapon /media/hdd/swapfile")
if self.mbox:
self.mbox.close()
def setSleep(self):
if self.bus() == _("External"):
Console().ePopen(("sdparm", "sdparm", "--flexible", "--readonly",
"--command=stop", self.disk_path))
else:
Console().ePopen(("hdparm", "hdparm", "-y", self.disk_path))
def populate2(self):
self.activityTimer.stop()
self.Console = Console()
niminfo = ""
nims = nimmanager.nimListCompressed()
for count in range(len(nims)):
if niminfo:
niminfo += "\n"
niminfo += nims[count]
self["nims"].setText(niminfo)
nims = nimmanager.nimList()
if len(nims) <= 4 :
for count in (0, 1, 2, 3):
if count < len(nims):
self["Tuner" + str(count)].setText(nims[count])
else:
self["Tuner" + str(count)].setText("")
else:
desc_list = []
count = 0
cur_idx = -1
while count < len(nims):
data = nims[count].split(":")
idx = data[0].strip('Tuner').strip()
desc = data[1].strip()
if desc_list and desc_list[cur_idx]['desc'] == desc:
desc_list[cur_idx]['end'] = idx
else:
desc_list.append({'desc' : desc, 'start' : idx, 'end' : idx})
cur_idx += 1
count += 1
for count in (0, 1, 2, 3):
if count < len(desc_list):
if desc_list[count]['start'] == desc_list[count]['end']:
text = "Tuner %s: %s" % (desc_list[count]['start'], desc_list[count]['desc'])
else:
text = "Tuner %s-%s: %s" % (desc_list[count]['start'], desc_list[count]['end'], desc_list[count]['desc'])
else:
text = ""
self["Tuner" + str(count)].setText(text)
self.list = []
list2 = []
f = open('/proc/partitions', 'r')
for line in f.readlines():
parts = line.strip().split()
if not parts:
continue
device = parts[3]
if not search('sd[a-z][1-9]', device):
continue
if device in list2:
continue
mount = '/dev/' + device
f = open('/proc/mounts', 'r')
for line in f.readlines():
if device in line:
parts = line.strip().split()
mount = str(parts[1])
break
f.close()
if not mount.startswith('/dev/'):
size = Harddisk(device).diskSize()
free = Harddisk(device).free()
if ((float(size) / 1024) / 1024) >= 1:
sizeline = _("Size: ") + str(round(((float(size) / 1024) / 1024), 2)) + _("TB")
elif (size / 1024) >= 1:
sizeline = _("Size: ") + str(round((float(size) / 1024), 2)) + _("GB")
elif size >= 1:
sizeline = _("Size: ") + str(size) + _("MB")
else:
sizeline = _("Size: ") + _("unavailable")
if ((float(free) / 1024) / 1024) >= 1:
freeline = _("Free: ") + str(round(((float(free) / 1024) / 1024), 2)) + _("TB")
elif (free / 1024) >= 1:
freeline = _("Free: ") + str(round((float(free) / 1024), 2)) + _("GB")
elif free >= 1:
freeline = _("Free: ") + str(free) + _("MB")
else:
freeline = _("Free: ") + _("full")
self.list.append(mount + '\t' + sizeline + ' \t' + freeline)
else:
self.list.append(mount + '\t' + _('Not mounted'))
list2.append(device)
self.list = '\n'.join(self.list)
self["hdd"].setText(self.list)
self.Console.ePopen("df -mh | grep -v '^Filesystem'", self.Stage1Complete)
def setMode(self, port, mode, rate, force=None):
print("[Videomode] VideoHardware setMode - port:", port, "mode:", mode, "rate:", rate)
# we can ignore "port"
self.current_mode = mode
self.current_port = port
modes = self.rates[mode][rate]
mode_50 = modes.get(50)
mode_60 = modes.get(60)
mode_24 = modes.get(24)
if mode_50 is None or force == 60:
mode_50 = mode_60
if mode_60 is None or force == 50:
mode_60 = mode_50
if mode_24 is None or force:
mode_24 = mode_60
if force == 50:
mode_24 = mode_50
if platform == "dmamlogic":
open('/sys/class/display/mode', 'w').write('576i50hz')
amlmode = mode + rate.lower()
print("[Videomode] Write to /sys/class/display/mode")
open('/sys/class/display/mode', 'w').write(amlmode)
print("[Videomode] Write to /sys/class/ppmgr/ppscaler")
open('/sys/class/ppmgr/ppscaler', 'w').write('1')
print("[Videomode] Write to /sys/class/ppmgr/ppscaler")
open('/sys/class/ppmgr/ppscaler', 'w').write('0')
size_width = getDesktop(0).size().width()
if size_width >= 1920:
Console().ePopen('fbset -fb /dev/fb0 -g 1920 1080 1920 3240 32')
else:
Console().ePopen('fbset -fb /dev/fb0 -g 1280 720 1280 2160 32')
return
try:
print("[Videomode] Write to /proc/stb/video/videomode_50hz")
open("/proc/stb/video/videomode_50hz", "w").write(mode_50)
print("[Videomode] Write to /proc/stb/video/videomode_60hz")
open("/proc/stb/video/videomode_60hz", "w").write(mode_60)
except IOError:
print("[Videomode] Write to /proc/stb/video/videomode_50hz failed.")
print("[Videomode] Write to /proc/stb/video/videomode_60hz failed.")
try:
# fallback if no possibility to setup 50/60 hz mode
print("[Videomode] Write to /proc/stb/video/videomode")
open("/proc/stb/video/videomode", "w").write(mode_50)
except IOError:
print("[Videomode] Write to /proc/stb/video/videomode failed.")
if BoxInfo.getItem("Has24hz"):
try:
print("[Videomode] Write to /proc/stb/video/videomode_24hz")
open("/proc/stb/video/videomode_24hz", "w").write(mode_24)
except IOError:
print("[Videomode] Write to /proc/stb/video/videomode_24hz failed.")
if brand == "gigablue":
try:
# use 50Hz mode (if available) for booting
print("[Videomode] Write to /etc/videomode")
open("/etc/videomode", "w").write(mode_50)
except IOError:
print("[Videomode] Write to /etc/videomode failed.")
self.updateAspect(None)
def __init__(self):
self.wlanIface = {}
self.backupWlanIface = {}
self.statusCallback = None
self.wlanConsole = Console()
def showDolby(self):
if self.dolbyAvailable:
Console().ePopen("fp_control -i 7 1") #Dolby
else:
Console().ePopen("fp_control -i 7 0")
def showMP3(self):
if self.mp3Available:
Console().ePopen("fp_control -i 11 1") #MP3
else:
Console().ePopen("fp_control -i 11 0")
def cancel(self):
main(self)
b = str(config.plugins.vfdicon.ledbright.value)
Console().ePopen("fp_control -led " + b)
ConfigListScreen.keyCancel(self)
def __init__(self, session):
self.session = session
self.onClose = []
print('[ADBVFD] Start')
self.tuned = False
self.play = False
self.record = False
self.timeshift = False
self.standby = False
self.usb = 0
self.dolbyAvailable = False
self.mp3Available = False
# self.DTSAvailable = False
self.display = 'led'
try:
print("[ADBVFD] Read /proc/stb/info/adb_variant")
self.adb_model = open("/proc/stb/info/adb_variant").read().strip()
except:
print("[ADBVFD] Read /proc/stb/info/adb_variant failed.")
print('[ADBVFD] ADB variant:', self.adb_model)
if self.adb_model == 'bsla' or self.adb_model == 'bzzb':
self.display = 'vfd'
self.timer = eTimer()
self.timer.callback.append(self.timerEvent)
self.timer.start(60000, False) # start one minute timer
if self.display == 'vfd':
Console().ePopen("fp_control -i 22 0")
b = str(config.plugins.vfdicon.ledbright.value)
Console().ePopen("fp_control -led " + b)
global DisplayType
print('[ADBVFD] Hardware displaytype:', DisplayType)
print('[ADBVFD] VFD displaytype :', DisplayTypevfd)
if DisplayType == 18:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evUpdatedInfo: self.UpdatedInfo,
iPlayableService.evUpdatedEventInfo: self.__evUpdatedEventInfo,
iPlayableService.evVideoSizeChanged: self.__evVideoSizeChanged,
iPlayableService.evSeekableStatusChanged: self.__evSeekableStatusChanged,
iPlayableService.evTunedIn: self.__evTunedIn,
iPlayableService.evTuneFailed: self.__evTuneFailed,
iPlayableService.evStart: self.__evStart
})
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call=False)
session.nav.record_event.append(self.gotRecordEvent)
if self.display == 'vfd':
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except:
pass
else:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evStart: self.writeName,
})
print('[ADBVFD] Set text scrolling option')
if config.plugins.vfdicon.textscroll.value is not None:
evfd.getInstance().vfd_set_SCROLL(int(config.plugins.vfdicon.textscroll.value))
else:
evfd.getInstance().vfd_set_SCROLL(1)
evfd.getInstance().vfd_set_CENTER(False)
if self.display == 'vfd':
print("[ADBVFD] Set text centering option")
if config.plugins.vfdicon.textcenter.value == "1":
evfd.getInstance().vfd_set_CENTER(True)
print('[ADBVFD] End initialisation')
def restoreBackUp(self):
Console().ePopen("rm -f /etc/fstab")
Console().ePopen("cp /etc/fstab.backup /etc/fstab")
self.buildScreen()
def mountall(self):
Console().ePopen("mount -a")
def buildMy_rec(self, device):
device2 = device[:-1] #strip device number
devicetype = path.realpath('/sys/block/' + device2 + '/device')
d2 = device
name = 'USB: '
mypixmap = '/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/dev_usbstick.png'
model = file('/sys/block/' + device2 + '/device/model').read()
model = str(model).replace('\n', '')
des = ''
if devicetype.find('/devices/pci') != -1:
name = _("HARD DISK: ")
mypixmap = '/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/dev_hdd.png'
name = name + model
from Components.Console import Console
self.Console = Console()
self.Console.ePopen(
"sfdisk -l /dev/sd? | grep swap | awk '{print $(NF-9)}' >/tmp/devices.tmp"
)
sleep(0.5)
f = open('/tmp/devices.tmp', 'r')
swapdevices = f.read()
f.close()
swapdevices = swapdevices.replace('\n', '')
swapdevices = swapdevices.split('/')
f = open('/proc/mounts', 'r')
for line in f.readlines():
if line.find(device) != -1:
parts = line.strip().split()
d1 = parts[1]
dtype = parts[2]
rw = parts[3]
break
continue
else:
if device in swapdevices:
parts = line.strip().split()
d1 = _("None")
dtype = 'swap'
rw = _("None")
break
continue
else:
d1 = _("None")
dtype = _("unavailable")
rw = _("None")
f.close()
f = open('/proc/partitions', 'r')
for line in f.readlines():
if line.find(device) != -1:
parts = line.strip().split()
size = int(parts[2])
if ((size / 1024) / 1024) > 1:
des = _("Size: ") + str(
(size / 1024) / 1024) + " " + _("GB")
else:
des = _("Size: ") + str(size / 1024) + " " + _("MB")
else:
try:
size = file('/sys/block/' + device2 + '/' + device +
'/size').read()
size = str(size).replace('\n', '')
size = int(size)
except:
size = 0
if (((size / 2) / 1024) / 1024) > 1:
des = _("Size: ") + str(
((size / 2) / 1024) / 1024) + " " + _("GB")
else:
des = _("Size: ") + str((size / 2) / 1024) + " " + _("MB")
f.close()
if des != '':
if rw.startswith('rw'):
rw = ' R/W'
elif rw.startswith('ro'):
rw = ' R/O'
else:
rw = ""
des += '\t' + _("Mount: ") + d1 + '\n' + _(
"Device: ") + ' /dev/' + device + '\t' + _(
"Type: ") + dtype + rw
png = LoadPixmap(mypixmap)
res = (name, des, png)
self.devicelist.append(res)
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = "Standby"
self.avswitch = AVSwitch()
print("[Standby] enter standby")
BoxInfo.setItem("StandbyState", True)
if os.path.exists("/usr/script/StandbyEnter.sh"):
Console().ePopen("/usr/script/StandbyEnter.sh &")
self["actions"] = ActionMap(
["StandbyActions"], {
"power": self.Power,
"power_make": self.Power_make,
"power_break": self.Power_break,
"power_long": self.Power_long,
"power_repeat": self.Power_repeat,
"discrete_on": self.Power
}, -1)
globalActionMap.setEnabled(False)
self.ignoreKeyBreakTimer = eTimer()
self.standbyStopServiceTimer = eTimer()
self.standbyStopServiceTimer.callback.append(self.stopService)
self.timeHandler = None
#mute adc
self.setMute()
if BoxInfo.getItem("Display") and BoxInfo.getItem("LCDMiniTV"):
# set LCDminiTV off
setLCDModeMinitTV("0")
self.paused_service = None
self.prev_running_service = None
self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
service = self.prev_running_service and self.prev_running_service.toString(
)
if service:
if service.startswith("1:") and service.rsplit(
":", 1)[1].startswith("/"):
self.paused_service = self.session.current_dialog
self.paused_service.pauseService()
if not self.paused_service:
self.timeHandler = eDVBLocalTimeHandler.getInstance()
if self.timeHandler.ready():
if self.session.nav.getCurrentlyPlayingServiceOrGroup():
self.stopService()
else:
self.standbyStopServiceTimer.startLongTimer(5)
self.timeHandler = None
else:
self.timeHandler.m_timeUpdated.get().append(self.stopService)
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
#set input to vcr scart
if BoxInfo.getItem("ScartSwitch"):
self.avswitch.setInput("SCART")
else:
self.avswitch.setInput("AUX")
if (getBrandOEM() in ('fulan', 'clap', 'dinobot') or getMachineBuild()
in ('gbmv200', 'sf8008', 'sf8008m', 'sf8008opt', 'ustym4kpro',
'beyonwizv2', 'viper4k')):
try:
open("/proc/stb/hdmi/output", "w").write("off")
except:
pass
if int(
config.usage.hdd_standby_in_standby.value
) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active
for hdd in harddiskmanager.HDDList():
hdd[1].setIdleTime(
int(config.usage.hdd_standby_in_standby.value))
self.onFirstExecBegin.append(self.__onFirstExecBegin)
self.onClose.append(self.__onClose)
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def startIpkgUpdate(self, callback=None): if not self.Console: self.Console = Console() cmd = self.ipkg.ipkg + " update" self.Console.ePopen(cmd, self.IpkgUpdateCB, callback)
def keyYellow(self):
if self["key_yellow"].getText() == _('Disconnect'):
print("[BluetoothManager] Disconnecting")
if brand not in ("xcore", "edision"):
cmd = "hidd --killall"
rc = Console().ePopen(cmd)
if not rc:
self["ConnStatus"].setText(_("No connected to any device"))
self["key_yellow"].setText(_("Connect"))
self.showConnections()
else:
paired_devices = iBluetoothctl.get_paired_devices()
if paired_devices is not None:
for d in paired_devices:
if d is not None:
mac_address = d['mac_address']
name = d['name']
try:
iBluetoothctl.remove(mac_address)
except:
pass
try:
iBluetoothctl.disconnect(mac_address)
except:
pass
msg = _("Disconnect with:\n"
) + name + " (" + mac_address + ")"
self["ConnStatus"].setText(msg)
self["key_yellow"].setText(_("Connect"))
else:
print("[BluetoothManager] Connecting")
selectedItem = self["devicelist"].getCurrent()
if selectedItem is None or selectedItem[
0] == "Scanning for devices...": ## If list is empty somehow or somebody pressed button while scanning
return
print("[BluetoothManager] trying to pair with: ", selectedItem[1])
msg = _("Trying to pair with:") + " " + selectedItem[1]
self["ConnStatus"].setText(msg)
if brand not in ("xcore", "edision"):
cmd = "hidd --connect " + selectedItem[1]
self.taskManager.append(cmd, self.cbPrintAvailConnections,
self.cbRunNextTask)
cmd = "hidd --show"
rc = Console().ePopen(cmd)
if rc:
print("[BluetoothManager] can NOT connect with: ",
selectedItem[1])
msg = _("Can't not pair with selected device!")
self["ConnStatus"].setText(msg)
self.taskManager.append(cmd, self.cbPrintCurrentConnections,
self.cbStopDone)
self.taskManager.next()
else:
mac_address = None
name = None
iBluetoothctl.pairable_on()
iBluetoothctl.start_scan()
for i in range(0, 20):
time.sleep(0.5)
available_devices = iBluetoothctl.get_available_devices()
if available_devices is not None:
for d in available_devices:
if selectedItem[1] in str(d):
mac_address = d['mac_address']
name = d['name']
if mac_address is not None:
break
if mac_address is not None:
iBluetoothctl.agent_noinputnooutput()
iBluetoothctl.default_agent()
ret = iBluetoothctl.pair(mac_address)
if config.btdevicesmanager.audioaddress.getValue() is "":
config.btdevicesmanager.audioaddress.setValue(
mac_address)
if ret is False:
if iBluetoothctl.passkey is not None:
self.cb_mac_address = mac_address
self.cb_name = name
msg = _("Please Enter Passkey: \n"
) + iBluetoothctl.passkey
self["ConnStatus"].setText(msg)
self.refreshStatusTimer.start(10000, True)
else:
iBluetoothctl.trust(mac_address)
ret = iBluetoothctl.connect(mac_address)
msg = _("Connection with:\n"
) + name + " (" + mac_address + ")"
self["ConnStatus"].setText(msg)
self["key_yellow"].setText(_("Disconnect"))
else:
print("[BluetoothManager] can NOT connect with: ",
selectedItem[1])
msg = _("Can't not pair with selected device!")
self["ConnStatus"].setText(msg)
def populate2(self):
self.activityTimer.stop()
self.Console = Console()
self.AboutText = _("Model:\t%s %s\n") % (getMachineBrand(),
getMachineName())
self.AboutText += "\n" + _("Detected NIMs:") + "\n"
nims = nimmanager.nimList()
for count in range(len(nims)):
if count < 4:
self["Tuner" + str(count)] = StaticText(nims[count])
else:
self["Tuner" + str(count)] = StaticText("")
self.AboutText += nims[count] + "\n"
self.AboutText += "\n" + _("Detected HDD:") + "\n"
self.list = []
list2 = []
f = open('/proc/partitions', 'r')
for line in f.readlines():
parts = line.strip().split()
if not parts:
continue
device = parts[3]
if not search('sd[a-z][1-9]', device):
continue
if device in list2:
continue
mount = '/dev/' + device
f = open('/proc/mounts', 'r')
for line in f.readlines():
if device in line:
parts = line.strip().split()
mount = str(parts[1])
break
f.close()
if not mount.startswith('/dev/'):
size = Harddisk(device).diskSize()
free = Harddisk(device).free()
if ((float(size) / 1024) / 1024) >= 1:
sizeline = _("Size: ") + str(
round(
((float(size) / 1024) / 1024), 2)) + " " + _("TB")
elif (size / 1024) >= 1:
sizeline = _("Size: ") + str(round(
(float(size) / 1024), 2)) + " " + _("GB")
elif size >= 1:
sizeline = _("Size: ") + str(size) + " " + _("MB")
else:
sizeline = _("Size: ") + _("unavailable")
if ((float(free) / 1024) / 1024) >= 1:
freeline = _("Free: ") + str(
round(
((float(free) / 1024) / 1024), 2)) + " " + _("TB")
elif (free / 1024) >= 1:
freeline = _("Free: ") + str(round(
(float(free) / 1024), 2)) + " " + _("GB")
elif free >= 1:
freeline = _("Free: ") + str(free) + " " + _("MB")
else:
freeline = _("Free: ") + _("full")
self.list.append(mount + '\t' + sizeline + ' \t' + freeline)
else:
self.list.append(mount + '\t' + _('Not mounted'))
list2.append(device)
self.list = '\n'.join(self.list)
self.AboutText += self.list + "\n"
self.AboutText += "\n" + _("Network Servers:") + "\n"
#self.mountinfo = _("none")
self.Console.ePopen("df -mh | grep -v '^Filesystem'",
self.Stage1Complete)
print("[mytest] Model = %s" % model)
print("[mytest] Platform = %s" % platform)
print("[mytest] SoC family = %s" % socfamily)
import enigma
import eConsoleImpl
import eBaseImpl
enigma.eTimer = eBaseImpl.eTimer
enigma.eSocketNotifier = eBaseImpl.eSocketNotifier
enigma.eConsoleAppContainer = eConsoleImpl.eConsoleAppContainer
if getVisionVersion().startswith("10") and not fileExists(
"/var/tmp/ntpv4.local") and platform != "dm4kgen":
from Components.Console import Console
print("[mytest] Try load all network interfaces.")
Console = Console()
Console.ePopen(
'/etc/init.d/networking restart ; /etc/init.d/samba.sh restart ; mount -a -t nfs,smbfs,cifs,ncpfs'
)
print("[mytest] All network interfaces loaded.")
from Components.SystemInfo import SystemInfo
if not SystemInfo["OpenVisionModule"]:
print(
"[mytest] Open Vision in multiboot! Now we have to remove what relies on our kernel module!"
)
from Components.Console import Console
Console = Console()
Console.ePopen('opkg remove enigma2-plugin-extensions-e2iplayer')
print("[mytest] Removed, this is on you not us!")
def getDataForInterface(self, iface, callback=None):
self.wlanConsole = Console()
if callback is not None:
self.statusCallback = callback
self.wlanConsole.ePopen(["/sbin/iwconfig", "/sbin/iwconfig", iface],
self.iwconfigFinished, iface)
def __init__(self):
# Init Timer
self.timer = eTimer()
self.Console = Console()
def __init__(self, session, menu_path=""):
Screen.__init__(self, session)
screentitle = _("Memory")
if config.usage.show_menupath.value == 'large':
menu_path += screentitle
title = menu_path
self["menu_path_compressed"] = StaticText("")
elif config.usage.show_menupath.value == 'small':
title = screentitle
self["menu_path_compressed"] = StaticText(
menu_path +
" >" if not menu_path.endswith(' / ') else menu_path[:-3] +
" >" or "")
else:
title = screentitle
self["menu_path_compressed"] = StaticText("")
Screen.setTitle(self, title)
self.skinName = ["SystemMemoryInfo", "About"]
self["lab1"] = StaticText(_("Virtuosso Image Xtreme"))
self["lab2"] = StaticText(_("By Team ViX"))
self["lab3"] = StaticText(
_("Support at %s") % "www.world-of-satellite.com")
self["AboutScrollLabel"] = ScrollLabel()
self["key_red"] = Button(_("Close"))
self["actions"] = ActionMap(["SetupActions", "ColorActions"], {
"cancel": self.close,
"ok": self.close,
"red": self.close,
})
out_lines = file("/proc/meminfo").readlines()
self.AboutText = _("RAM") + '\n\n'
RamTotal = "-"
RamFree = "-"
for lidx in range(len(out_lines) - 1):
tstLine = out_lines[lidx].split()
if "MemTotal:" in tstLine:
MemTotal = out_lines[lidx].split()
self.AboutText += _(
"Total memory:") + "\t" + MemTotal[1] + "\n"
if "MemFree:" in tstLine:
MemFree = out_lines[lidx].split()
self.AboutText += _("Free memory:") + "\t" + MemFree[1] + "\n"
if "Buffers:" in tstLine:
Buffers = out_lines[lidx].split()
self.AboutText += _("Buffers:") + "\t" + Buffers[1] + "\n"
if "Cached:" in tstLine:
Cached = out_lines[lidx].split()
self.AboutText += _("Cached:") + "\t" + Cached[1] + "\n"
if "SwapTotal:" in tstLine:
SwapTotal = out_lines[lidx].split()
self.AboutText += _("Total swap:") + "\t" + SwapTotal[1] + "\n"
if "SwapFree:" in tstLine:
SwapFree = out_lines[lidx].split()
self.AboutText += _("Free swap:") + "\t" + SwapFree[1] + "\n\n"
self["actions"].setEnabled(False)
self.Console = Console()
self.Console.ePopen("df -mh / | grep -v '^Filesystem'",
self.Stage1Complete)
def __init__(self): self.callback = None self.Console = Console()
def updateStatus(self):
print("[TVCharts] Status Update ...")
self.DBStatusTimer.stop()
if not config.plugins.tvcharts.enabled.value or Screens.Standby.inStandby:
return
# Get Channelname
sref = self.session.nav.getCurrentlyPlayingServiceReference()
if sref is not None:
ref = eServiceReference(sref.toString())
ref.setName("")
serviceHandler = eServiceCenter.getInstance()
info = serviceHandler.info(ref)
channel_name = info and info.getName(ref).replace(
'\xc2\x86', '').replace('\xc2\x87', '').decode(
"utf-8", "ignore").encode("utf-8") or ""
self.serviceref = ref.toString()
else:
channel_name = ""
self.serviceref = ""
# Get Event Info
service = self.session.nav.getCurrentService()
info = service and service.info()
event = info and info.getEvent(0)
event_name = event and event.getEventName() or ""
event_description = ""
event_begin = 0
if event is not None:
curEvent = parseEvent(event)
event_begin = int(
curEvent[0]) + (config.recording.margin_before.getValue() * 60)
event_description = event.getExtendedDescription()
# Get Box Info
self.BoxID = iNetwork.getAdapterAttribute("eth0", "mac")
self.DeviceName = BoxInfo.getItem("model")
try:
from enigma import getEnigmaVersionString
self.EnigmaVersion = getEnigmaVersionString()
self.ImageVersion = BoxInfo.getItem(
"imageversion") + '.' + BoxInfo.getItem("imagebuild")
except:
self.EnigmaVersion = about.getEnigmaVersionString()
self.ImageVersion = BoxInfo.getItem("imgversion")
# Get TimerList
self.timerlist = ""
if config.plugins.tvcharts.submittimers.value and self.LastTimerlistUpdate <= (
time() - 1800):
self.LastTimerlistUpdate = time()
try:
for timer in self.recordtimer.timer_list:
if timer.disabled == 0 and timer.justplay == 0:
self.timerlist += "%s|%s|%s|%s|%s|%s|%s\n" % (
timer.eit,
str(
int(timer.begin) +
(config.recording.margin_before.getValue() *
60)),
str(
int(timer.end) -
(config.recording.margin_after.getValue() *
60)), str(timer.service_ref), timer.name,
timer.service_ref.getServiceName().replace(
'\xc2\x86', '').replace('\xc2\x87', '').decode(
"utf-8",
"ignore").encode("utf-8"), timer.repeated)
except Exception:
print("[TVCharts] Error loading timers!")
# Get Pluginlist
if config.plugins.tvcharts.submitplugins.value and self.pluginlist == "":
try:
Console().ePopen(
"opkg list_installed | grep enigma2-plugin- > /tmp/plugins.txt"
)
for plugin in open('/tmp/plugins.txt', 'r'):
self.pluginlist += plugin[0:plugin.find(' - ')] + "\n"
Console().ePopen("rm -f /tmp/plugins.txt")
except Exception:
print("[TVCharts] Error loading plugins!")
# Status Update
getPage(
url='http://www.dreambox-plugins.de/feeds/TVCharts/status.php',
agent="Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)",
timeout=60,
method='POST',
headers={
'Content-Type': 'application/x-www-form-urlencoded'
},
postdata=urlencode({
'boxid': self.BoxID,
'devicename': self.DeviceName,
'imageversion': self.ImageVersion,
'enigmaversion': self.EnigmaVersion,
'lastchannel': channel_name,
'lastevent': event_name,
'eventdescr': event_description,
'lastbegin': event_begin,
'lastserviceref': self.serviceref,
'timerlist': self.timerlist,
'pluginlist': self.pluginlist
})).addErrback(self.updateError)
# Restart Timer
self.DBStatusTimer.start(900000, True)
def grab(self, file):
if not self.Console:
self.Console = Console()
self.Console.ePopen('/usr/bin/grab -v -r 250 -l -j 100 "%s"'%file, self.grabDone)
def MakeSwapFile(self, result, retval, extra_args):
Console().ePopen("mkswap /media/hdd/swapfile", self.EnableSwapFile)
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = "Standby"
self.avswitch = AVSwitch()
print "[Standby] enter standby"
if path.exists("/usr/scripts/standby_enter.sh"):
Console().ePopen("/usr/scripts/standby_enter.sh")
self["actions"] = ActionMap( [ "StandbyActions" ],
{
"power": self.Power,
"discrete_on": self.Power
}, -1)
globalActionMap.setEnabled(False)
from Screens.InfoBar import InfoBar
self.infoBarInstance = InfoBar.instance
self.standbyStopServiceTimer = eTimer()
self.standbyStopServiceTimer.callback.append(self.stopService)
self.timeHandler = None
self.setMute()
if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]:
# set LCDminiTV off
setLCDMiniTVMode("0")
self.paused_service = self.paused_action = False
self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup()
if Components.ParentalControl.parentalControl.isProtected(self.prev_running_service):
self.prev_running_service = eServiceReference(config.tv.lastservice.value)
service = self.prev_running_service and self.prev_running_service.toString()
if service:
if service.rsplit(":", 1)[1].startswith("/"):
self.paused_service = hasattr(self.session.current_dialog, "pauseService") and hasattr(self.session.current_dialog, "unPauseService") and self.session.current_dialog or self.infoBarInstance
self.paused_action = hasattr(self.paused_service, "seekstate") and hasattr(self.paused_service, "SEEK_STATE_PLAY") and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY
self.paused_action and self.paused_service.pauseService()
if not self.paused_service:
self.timeHandler = eDVBLocalTimeHandler.getInstance()
if self.timeHandler.ready():
if self.session.nav.getCurrentlyPlayingServiceOrGroup():
self.stopService()
else:
self.standbyStopServiceTimer.startLongTimer(5)
self.timeHandler = None
else:
self.timeHandler.m_timeUpdated.get().append(self.stopService)
if self.session.pipshown:
self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP()
if getBrandOEM() in ('dinobot') or SystemInfo["HasHiSi"]:
try:
open("/proc/stb/hdmi/output", "w").write("off")
except:
pass
self.onFirstExecBegin.append(self.__onFirstExecBegin)
self.onClose.append(self.__onClose)
def checkNetworkState(self,statecallback):
self.NetworkState = 0
self.pingConsole = Console()
for server in ("www.openpli.org", "www.google.nl", "www.google.com"):
self.pingConsole.ePopen(("/bin/ping", "/bin/ping", "-c", "1", server), self.checkNetworkStateFinished,statecallback)
def __init__(self, session, StandbyCounterIncrease=True):
Screen.__init__(self, session)
self.skinName = "Standby"
self.avswitch = AVSwitch()
print "[Standby] enter standby"
if os.path.exists("/usr/script/Standby.sh"):
Console().ePopen("/usr/script/Standby.sh off")
if os.path.exists("/usr/script/standby_enter.sh"):
Console().ePopen("/usr/script/standby_enter.sh")
self["actions"] = ActionMap( [ "StandbyActions" ],
{
"power": self.Power,
"discrete_on": self.Power
}, -1)
globalActionMap.setEnabled(False)
from Screens.InfoBar import InfoBar
from Screens.SleepTimerEdit import isNextWakeupTime
self.infoBarInstance = InfoBar.instance
self.StandbyCounterIncrease = StandbyCounterIncrease
self.standbyTimeoutTimer = eTimer()
self.standbyTimeoutTimer.callback.append(self.standbyTimeout)
self.standbyStopServiceTimer = eTimer()
self.standbyStopServiceTimer.callback.append(self.stopService)
self.standbyWakeupTimer = eTimer()
self.standbyWakeupTimer.callback.append(self.standbyWakeup)
self.timeHandler = None
self.setMute()
# set LCDminiTV off
if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]:
setLCDModeMinitTV("0")
self.paused_service = self.paused_action = False
self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup()
if Components.ParentalControl.parentalControl.isProtected(self.prev_running_service):
self.prev_running_service = eServiceReference(config.tv.lastservice.value)
service = self.prev_running_service and self.prev_running_service.toString()
if service:
if service.rsplit(":", 1)[1].startswith("/"):
self.paused_service = hasattr(self.session.current_dialog, "pauseService") and hasattr(self.session.current_dialog, "unPauseService") and self.session.current_dialog or self.infoBarInstance
self.paused_action = hasattr(self.paused_service, "seekstate") and hasattr(self.paused_service, "SEEK_STATE_PLAY") and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY
self.paused_action and self.paused_service.pauseService()
if not self.paused_service:
self.timeHandler = eDVBLocalTimeHandler.getInstance()
if self.timeHandler.ready():
if self.session.nav.getCurrentlyPlayingServiceOrGroup():
self.stopService()
else:
self.standbyStopServiceTimer.startLongTimer(5)
self.timeHandler = None
else:
self.timeHandler.m_timeUpdated.get().append(self.stopService)
if self.session.pipshown:
self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP()
if SystemInfo["ScartSwitch"]:
self.avswitch.setInput("SCART")
else:
self.avswitch.setInput("AUX")
gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value)
if gotoShutdownTime:
self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime)
gotoWakeupTime = isNextWakeupTime(True)
if gotoWakeupTime != -1:
curtime = localtime(time())
if curtime.tm_year > 1970:
wakeup_time = int(gotoWakeupTime - time())
if wakeup_time > 0:
self.standbyWakeupTimer.startLongTimer(wakeup_time)
self.onFirstExecBegin.append(self.__onFirstExecBegin)
self.onClose.append(self.__onClose)
