def Qtuner(self):
self.sublist = []
if not SystemInfo["IPTVSTB"]:
self.sublist.append(
QuickSubMenuEntryComponent(
_("Tuner allocation"), _("Configure tuner use"),
_("Customize how tuners are allocated and used")))
dvbs_nimList = nimmanager.getNimListOfType("DVB-S")
dvbt_nimList = nimmanager.getNimListOfType("DVB-T")
if len(dvbs_nimList) != 0:
self.sublist.append(
QuickSubMenuEntryComponent(
_("Tuner configuration"), _("Setup tuner(s)"),
_("Setup each tuner for your satellite system")))
self.sublist.append(
QuickSubMenuEntryComponent(
_("Automatic scan"), _("Service search"),
_("Automatic scan for services")))
if len(dvbt_nimList) != 0:
self.sublist.append(
QuickSubMenuEntryComponent(
_("Tuner configuration"), _("Configure tuner(s)"),
_("Select the tuner operating mode and delivery system"
)))
self.sublist.append(
QuickSubMenuEntryComponent(
_("Location scan"), _("Automatic location scan"),
_("Automatic scan for services based on your location")
))
self.sublist.append(
QuickSubMenuEntryComponent(_("Manual scan"),
_("Service search"),
_("Manual scan for services")))
if BLINDSCAN and len(dvbs_nimList) != 0:
self.sublist.append(
QuickSubMenuEntryComponent(_("Blind scan"),
_("Blind search"),
_("Blind scan for services")))
if HAVE_SATFINDER and len(dvbs_nimList) != 0:
self.sublist.append(
QuickSubMenuEntryComponent(
_("Sat finder"), _("Search sats"),
_("Search sats, check signal and lock")))
if HAVE_LCN_SCANNER:
self.sublist.append(
QuickSubMenuEntryComponent(_("LCN renumber"),
_("Automatic LCN assignment"),
_("Automatic LCN assignment")))
if REMOTEBOX:
self.sublist.append(
QuickSubMenuEntryComponent(
_("Remote IP channels"), _("Setup channel server IP"),
_("Setup server IP for your IP channels")))
self["sublist"].list = self.sublist
def discoverJSON(self, dvb_type):
ip = getIP()
ip_port = 'http://%s:%s' % (ip, tunerports[dvb_type])
device_uuid = str(uuid.uuid4())
if path.exists('/www/%s/discover.json' % tunerfolders[dvb_type]) and path.exists('/www/%s/device.xml' % tunerfolders[dvb_type]):
with open('/www/%s/discover.json' % tunerfolders[dvb_type]) as data_file:
discover[dvb_type] = json.load(data_file)
elif path.exists('/www/%s/discover.json' % tunerfolders[dvb_type]) and not path.exists('/www/%s/device.xml' % tunerfolders[dvb_type]):
with open('/www/%s/discover.json' % tunerfolders[dvb_type]) as data_file:
discover[dvb_type] = json.load(data_file)
discover[dvb_type]['DeviceUUID']='%s' % device_uuid
print 'device_uuids_1:',device_uuid
else:
discover[dvb_type] = {}
deviceauth = generator(24, charset['auth'])
deviceid = generator(8, charset['id'])
if brandingmodule:
discover[dvb_type]['FriendlyName']='%s %s' % (getMachineBrand(), getMachineName())
discover[dvb_type]['ModelNumber']='%s' % getBoxType()
discover[dvb_type]['FirmwareName']='%s' % getImageDistro()
discover[dvb_type]['FirmwareVersion']='%s' % getDriverDate()
else:
discover[dvb_type]['FriendlyName']='%s' % _('Enigma2 STB')
discover[dvb_type]['ModelNumber']='%s' % getBoxType()
discover[dvb_type]['FirmwareName']='%s' % _('Enigma2')
discover[dvb_type]['FirmwareVersion']='%s' % getEnigmaVersionString()
discover[dvb_type]['DeviceID']='%s' % deviceid
discover[dvb_type]['DeviceAuth']='%s' % deviceauth
discover[dvb_type]['BaseURL']='%s' % ip_port
discover[dvb_type]['LineupURL']='%s/lineup.json' % ip_port
discover[dvb_type]['TunerCount']=len(nimmanager.getNimListOfType(dvb_type)) if dvb_type != "multi" else len(nimmanager.nimList())
discover[dvb_type]['NumChannels']=getlineup.noofchannels(dvb_type)
discover[dvb_type]['DeviceUUID']='%s' % device_uuid
return discover
def checkLoopthrough(self):
if self.nimConfig.configMode.value == "loopthrough":
loopthrough_count = 0
dvbs_slots = nimmanager.getNimListOfType('DVB-S')
dvbs_slots_len = len(dvbs_slots)
for x in dvbs_slots:
try:
nim_slot = nimmanager.nim_slots[x]
if nim_slot == self.nimConfig:
self_idx = x
if nim_slot.config.configMode.value == "loopthrough":
loopthrough_count += 1
except: pass
if loopthrough_count >= dvbs_slots_len:
return False
self.slot_dest_list = []
def checkRecursiveConnect(slot_id):
if slot_id in self.slot_dest_list:
return False
self.slot_dest_list.append(slot_id)
slot_config = nimmanager.nim_slots[slot_id].config
if slot_config.configMode.value == "loopthrough":
return checkRecursiveConnect(int(slot_config.connectedTo.value))
return True
return checkRecursiveConnect(self.slotid)
def checkLoopthrough(self):
if self.nimConfig.configMode.value == "loopthrough":
loopthrough_count = 0
dvbs_slots = nimmanager.getNimListOfType('DVB-S')
dvbs_slots_len = len(dvbs_slots)
for x in dvbs_slots:
try:
nim_slot = nimmanager.nim_slots[x]
if nim_slot == self.nimConfig:
self_idx = x
if nim_slot.config.configMode.value == "loopthrough":
loopthrough_count += 1
except: pass
if loopthrough_count >= dvbs_slots_len:
return False
self.slot_dest_list = []
def checkRecursiveConnect(slot_id):
if slot_id in self.slot_dest_list:
return False
self.slot_dest_list.append(slot_id)
slot_config = nimmanager.nim_slots[slot_id].config
if slot_config.configMode.value == "loopthrough":
return checkRecursiveConnect(int(slot_config.connectedTo.value))
return True
return checkRecursiveConnect(self.slotid)
def __init__(self, session):
Screen.__init__(self, session)
self["actions"] = ActionMap(["SetupActions", "MenuActions"],
{
"ok": self.keyGo,
"cancel": self.keyCancel,
"menu": self.closeRecursive,
}, -2)
nimlist = nimmanager.getNimListOfType("DVB-C")
nim_list = []
for x in nimlist:
nim_list.append((nimmanager.nim_slots[x].slot, nimmanager.nim_slots[x].friendly_full_description))
self.scan_nims = ConfigSelection(choices = nim_list)
self.list = []
self.list.append(getConfigListEntry(_("Tuner"), self.scan_nims))
self.list.append(getConfigListEntry(_('Frequency'), config.plugins.CableScan.frequency))
self.list.append(getConfigListEntry(_('Symbol rate'), config.plugins.CableScan.symbolrate))
self.list.append(getConfigListEntry(_('Modulation'), config.plugins.CableScan.modulation))
self.list.append(getConfigListEntry(_('Network ID'), config.plugins.CableScan.networkid))
self.list.append(getConfigListEntry(_("Use official channel numbering"), config.plugins.CableScan.keepnumbering))
self.list.append(getConfigListEntry(_("HD list"), config.plugins.CableScan.hdlist))
ConfigListScreen.__init__(self, self.list)
self["config"].list = self.list
self["config"].l.setList(self.list)
self.finished_cb = None
self["introduction"] = Label(_("Configure your network settings, and press OK to start the scan"))
def PositionerMain(self):
nimList = nimmanager.getNimListOfType('DVB-S')
if len(nimList) == 0:
self.session.open(MessageBox,
_('No positioner capable frontend found.'),
MessageBox.TYPE_ERROR)
elif len(
NavigationInstance.instance.getRecordings(
False, pNavigation.isAnyRecording)) > 0:
self.session.open(
MessageBox,
_('A recording is currently running. Please stop the recording before trying to configure the positioner.'
), MessageBox.TYPE_ERROR)
else:
usableNims = []
for x in nimList:
configured_rotor_sats = nimmanager.getRotorSatListForNim(x)
if len(configured_rotor_sats) != 0:
usableNims.append(x)
if len(usableNims) == 1:
self.session.open(PositionerSetup, usableNims[0])
elif len(usableNims) > 1:
self.session.open(RotorNimSelection)
else:
self.session.open(
MessageBox,
_('No tuner is configured for use with a diseqc positioner!'
), MessageBox.TYPE_ERROR)
def SatfinderMain(session, close=None, **kwargs):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if nimmanager.getNimConfig(x).configMode.value in ("loopthrough",
"satposdepends",
"nothing"):
continue
if nimmanager.getNimConfig(x).configMode.value == "advanced" and len(
nimmanager.getSatListForNim(x)) < 1:
continue
nimList.append(x)
if len(nimList) == 0:
session.open(
MessageBox,
_("No satellites configured. Plese check your tuner setup."),
MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(
MessageBox,
_("A recording is currently running. Please stop the recording before trying to start the satfinder."
), MessageBox.TYPE_ERROR)
else:
session.openWithCallback(close, Satfinder)
def CableScanAuto():
nimlist = nimmanager.getNimListOfType("DVB-C")
if nimlist:
if Session.nav.RecordTimer.isRecording():
restartScanAutoStartTimer()
else:
Session.openWithCallback(restartScanAutoStartTimer, CableScanAutoScreen, nimlist)
def __init__(self, session):
Screen.__init__(self, session)
self["actions"] = ActionMap(["SetupActions", "MenuActions"],
{
"ok": self.keyGo,
"cancel": self.keyCancel,
"menu": self.closeRecursive,
}, -2)
nimlist = nimmanager.getNimListOfType("DVB-C")
nim_list = []
for x in nimlist:
nim_list.append((nimmanager.nim_slots[x].slot, nimmanager.nim_slots[x].friendly_full_description))
self.scan_nims = ConfigSelection(choices = nim_list)
self.list = []
self.list.append(getConfigListEntry(_("Tuner"), self.scan_nims))
self.list.append(getConfigListEntry(_('Frequency'), config.plugins.CableScan.frequency))
self.list.append(getConfigListEntry(_('Symbol rate'), config.plugins.CableScan.symbolrate))
self.list.append(getConfigListEntry(_('Modulation'), config.plugins.CableScan.modulation))
self.list.append(getConfigListEntry(_('Network ID'), config.plugins.CableScan.networkid))
self.list.append(getConfigListEntry(_("Use official channel numbering"), config.plugins.CableScan.keepnumbering))
self.list.append(getConfigListEntry(_("HD list"), config.plugins.CableScan.hdlist))
ConfigListScreen.__init__(self, self.list)
self["config"].list = self.list
self["config"].l.setList(self.list)
self.finished_cb = None
self["introduction"] = Label(_("Configure your network settings, and press OK to start the scan"))
def PositionerMain(session, **kwargs):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
session.open(MessageBox, _("No positioner capable frontend found."),
MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(
MessageBox,
_("A recording is currently running. Please stop the recording before trying to configure the positioner."
), MessageBox.TYPE_ERROR)
else:
usableNims = []
for x in nimList:
configured_rotor_sats = nimmanager.getRotorSatListForNim(x)
if len(configured_rotor_sats) != 0:
usableNims.append(x)
if len(usableNims) == 1:
session.open(PositionerSetup, usableNims[0])
elif len(usableNims) > 1:
session.open(RotorNimSelection)
else:
session.open(
MessageBox,
_("No tuner is configured for use with a diseqc positioner!"
), MessageBox.TYPE_ERROR)
def prepare(self):
self.providers = Providers().read()
self.providers_configs = {}
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])
# read providers configurations
providers_tmp_configs = {}
providers_tmp = config.plugins.RadioTimesEmulator.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()]["transponder"][
"orbital_position"] not in self.orbital_supported:
continue
providers_tmp_configs[
provider_config.getProvider()] = provider_config
# build providers configurations
for provider in self.providers.keys():
self.providers_configs[provider] = ConfigYesNo(
default=provider in providers_tmp_configs.keys())
def PositionerMain(self):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
self.session.open(MessageBox, _("No positioner capable frontend found."), MessageBox.TYPE_ERROR)
else:
if len(NavigationInstance.instance.getRecordings()) > 0:
self.session.open(
MessageBox,
_(
"A recording is currently running. Please stop the recording before trying to configure the positioner."
),
MessageBox.TYPE_ERROR,
)
else:
usableNims = []
for x in nimList:
configured_rotor_sats = nimmanager.getRotorSatListForNim(x)
if len(configured_rotor_sats) != 0:
usableNims.append(x)
if len(usableNims) == 1:
self.session.open(PositionerSetup, usableNims[0])
elif len(usableNims) > 1:
self.session.open(RotorNimSelection)
else:
self.session.open(
MessageBox, _("No tuner is configured for use with a diseqc positioner!"), MessageBox.TYPE_ERROR
)
def CableScanAuto():
nimlist = nimmanager.getNimListOfType("DVB-C")
if nimlist:
if Session.nav.RecordTimer.isRecording():
restartScanAutoStartTimer()
else:
Session.openWithCallback(restartScanAutoStartTimer, CableScanAutoScreen, nimlist)
def CableScanMain(session, **kwargs):
nimlist = nimmanager.getNimListOfType("DVB-C")
if nimlist:
Session.open(CableScanScreen, nimlist)
else:
Session.open(MessageBox,
_("No cable tuner found!"),
type=MessageBox.TYPE_ERROR)
def Qtuner(self):
dvbs_nimList = nimmanager.getNimListOfType("DVB-S")
dvbt_nimList = nimmanager.getNimListOfType("DVB-T")
self.sublist = []
if len(dvbs_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Tuner Configuration",_("Setup tuner(s)"),_("Setup each tuner for your satellite system")))
self.sublist.append(QuickSubMenuEntryComponent("Automatic Scan",_("Service Searching"),_("Automatic scan for services")))
if len(dvbt_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Location Scan",_("Automatic Location Scan"),_("Automatic scan for services based on your location")))
self.sublist.append(QuickSubMenuEntryComponent("Manual Scan",_("Service Searching"),_("Manual scan for services")))
if REMOTEBOX == True:
self.sublist.append(QuickSubMenuEntryComponent("Remote IP Channels",_("Setup Channels Server IP"),_("Setup server IP for your IP channels")))
if BLINDSCAN == True and len(nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Blind Scan",_("Blind Searching"),_("Blind scan for services")))
if HAVE_SATFINDER and len(nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Sat Finder",_("Search Sats"),_("Search Sats, check signal and lock")))
self["sublist"].l.setList(self.sublist)
def SimpleSatScanMain(session, **kwargs):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start a service scan."), MessageBox.TYPE_ERROR)
else:
session.open(SimpleSatScan)
def DiseqcTesterMain(session, **kwargs):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start a testing DiSEqC."), MessageBox.TYPE_ERROR)
else:
session.open(DiseqcTesterNimSelection)
def DiseqcTesterMain(session, **kwargs):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start a testing DiSEqC."), MessageBox.TYPE_ERROR)
else:
session.open(DiseqcTesterNimSelection)
def getUsableRotorNims(only_first=False):
usableRotorNims = []
nimList = nimmanager.getNimListOfType("DVB-S")
for nim in nimList:
if nimmanager.getRotorSatListForNim(nim, only_first=only_first):
usableRotorNims.append(nim)
if only_first:
break
return usableRotorNims
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
for x in self["config"].list:
x[1].save()
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
for x in self["config"].list:
x[1].save()
def __init__(self, session):
Screen.__init__(self, session)
nimlist = nimmanager.getNimListOfType("DVB-S")
nimMenuList = []
for x in nimlist:
nimMenuList.append((nimmanager.nim_slots[x].friendly_full_description, x))
self["nimlist"] = MenuList(nimMenuList)
self["actions"] = ActionMap(["OkCancelActions"], {"ok": self.okbuttonClick, "cancel": self.close}, -1)
def Qtuner(self):
self.sublist = []
if not SystemInfo["IPTVSTB"]:
self.sublist.append(QuickSubMenuEntryComponent("Tuner setup", _("Configure tuners"), _("Customize how tuners are used")))
dvbs_nimList = nimmanager.getNimListOfType("DVB-S")
dvbt_nimList = nimmanager.getNimListOfType("DVB-T")
if len(dvbs_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Tuner configuration", _("Setup tuner(s)"), _("Setup each tuner for your satellite system")))
self.sublist.append(QuickSubMenuEntryComponent("Automatic scan", _("Service search"), _("Automatic scan for services")))
if len(dvbt_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Location scan", _("Automatic location scan"), _("Automatic scan for services based on your location")))
self.sublist.append(QuickSubMenuEntryComponent("Manual scan", _("Service search"), _("Manual scan for services")))
if BLINDSCAN and len(dvbs_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Blind scan", _("Blind search"), _("Blind scan for services")))
if HAVE_SATFINDER and len(dvbs_nimList) != 0:
self.sublist.append(QuickSubMenuEntryComponent("Sat finder", _("Search sats"), _("Search sats, check signal and lock")))
if HAVE_LCN_SCANNER:
self.sublist.append(QuickSubMenuEntryComponent("LCN renumber", _("Automatic LCN assignment"), _("Automatic LCN assignment")))
if REMOTEBOX:
self.sublist.append(QuickSubMenuEntryComponent("Remote IP channels", _("Setup channel server IP"), _("Setup server IP for your IP channels")))
self["sublist"].l.setList(self.sublist)
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
# sanity check for empty sat list
if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1:
self.nimConfig.configMode.value = "nothing"
for x in self["config"].list:
x[1].save()
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
# sanity check for empty sat list
if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1:
self.nimConfig.configMode.value = "nothing"
for x in self["config"].list:
x[1].save()
def SimpleSatScanMain(session, **kwargs):
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!"),
MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(
MessageBox,
_("A recording is currently running. Please stop the recording before trying to start a service scan."
), MessageBox.TYPE_ERROR)
else:
session.open(SimpleSatScan)
def saveAll(self):
if self.nim.isCompatible('DVB-S'):
choices = []
nimlist = nimmanager.getNimListOfType('DVB-S', self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
if self.nimConfig.configMode.value != 'satposdepends' and len(nimmanager.getSatListForNim(self.slotid)) < 1:
self.nimConfig.configMode.value = 'nothing'
for x in self['config'].list:
x[1].save()
configfile.save()
def SatfinderMain(session, close = None, **kwargs):
nims = nimmanager.getNimListOfType('DVB-S')
nimList = []
for x in nims:
if nimmanager.getNimConfig(x).configMode.value in ('loopthrough', 'satposdepends', 'nothing'):
continue
if nimmanager.getNimConfig(x).configMode.value == 'advanced' and len(nimmanager.getSatListForNim(x)) < 1:
continue
nimList.append(x)
if len(nimList) == 0:
session.open(MessageBox, _('No satellites configured. Plese check your tuner setup.'), MessageBox.TYPE_ERROR)
else:
session.openWithCallback(close, Satfinder)
def CableScanMain(session, **kwargs):
nims = nimmanager.getNimListOfType("DVB-C")
nimList = []
for x in nims:
nimList.append(x)
if len(nimList) == 0:
session.open(MessageBox, _("No cable tuner found!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to scan."), MessageBox.TYPE_ERROR)
else:
session.open(CableScanScreen)
def CableScanMain(session, **kwargs):
nims = nimmanager.getNimListOfType("DVB-C")
nimList = []
for x in nims:
nimList.append(x)
if len(nimList) == 0:
session.open(MessageBox, _("No cable tuner found!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to scan."), MessageBox.TYPE_ERROR)
else:
session.open(CableScanScreen)
def SatfinderMain(self):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if not nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
nimList.append(x)
if len(nimList) == 0:
self.session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
else:
if len(NavigationInstance.instance.getRecordings()) > 0:
self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
self.session.open(Satfinder)
def SatfinderMain(self):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if not nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
nimList.append(x)
if len(nimList) == 0:
self.session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
else:
if len(NavigationInstance.instance.getRecordings()) > 0:
self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
self.session.open(Satfinder)
def __init__(self, session):
Screen.__init__(self, session)
nimlist = nimmanager.getNimListOfType("DVB-S")
nimMenuList = []
for x in nimlist:
nimMenuList.append(
(nimmanager.nim_slots[x].friendly_full_description, x))
self["nimlist"] = MenuList(nimMenuList)
self["actions"] = ActionMap(["OkCancelActions"], {
"ok": self.okbuttonClick,
"cancel": self.close
}, -1)
def __init__(self, session):
Screen.__init__(self, session)
Screen.setTitle(self, _("Satfinder"))
nimlist = nimmanager.getNimListOfType("DVB-S")
nimMenuList = []
for x in nimlist:
if not nimmanager.getNimConfig(x).configMode.getValue() in ("loopthrough", "satposdepends", "nothing"):
nimMenuList.append((nimmanager.nim_slots[x].friendly_full_description, x))
self["nimlist"] = MenuList(nimMenuList)
self["actions"] = ActionMap(["OkCancelActions"],
{
"ok": self.okbuttonClick ,
"cancel": self.close
}, -1)
def SatfinderMain(self):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
continue
if nimmanager.getNimConfig(x).configMode.value == "advanced" and len(nimmanager.getSatListForNim(x)) < 1:
continue
nimList.append(x)
if len(nimList) == 0:
self.session.open(MessageBox, _("No satellites configured. Plese check your tuner setup."), MessageBox.TYPE_ERROR)
else:
if self.session.nav.RecordTimer.isRecording():
self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
self.session.open(Satfinder)
def SatfinderMain(session, **kwargs):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if not nimmanager.getNimConfig(x).configMode.getValue() in ("loopthrough", "satposdepends", "nothing"):
nimList.append(x)
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
if len(nimList) == 1:
session.open(Satfinder, nimList[0])
else:
session.open(SatNimSelection)
def __init__(self, session):
Screen.__init__(self, session)
Screen.setTitle(self, _("Satfinder"))
nimlist = nimmanager.getNimListOfType("DVB-S")
nimMenuList = []
for x in nimlist:
if not nimmanager.getNimConfig(x).configMode.getValue() in (
"loopthrough", "satposdepends", "nothing"):
nimMenuList.append(
(nimmanager.nim_slots[x].friendly_full_description, x))
self["nimlist"] = MenuList(nimMenuList)
self["actions"] = ActionMap(["OkCancelActions"], {
"ok": self.okbuttonClick,
"cancel": self.close
}, -1)
def SatfinderMain(session, **kwargs):
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if not nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
nimList.append(x)
if len(nimList) == 0:
session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
else:
if session.nav.RecordTimer.isRecording():
session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
if len(nimList) == 1:
session.open(Satfinder, nimList[0])
else:
session.open(SatNimSelection)
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
# sanity check for empty sat list
if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1:
self.nimConfig.configMode.value = "nothing"
if self.nim.isFBCRoot():
if SystemInfo["HasForceLNBOn"]:
config.misc.forceLnbPower.save()
if SystemInfo["HasForceToneburst"]:
config.misc.forceToneBurst.save()
for x in self["config"].list:
x[1].save()
configfile.save()
def saveAll(self):
if self.nim.isCompatible("DVB-S"):
# reset connectedTo to all choices to properly store the default value
choices = []
nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
for id in nimlist:
choices.append((str(id), nimmanager.getNimDescription(id)))
self.nimConfig.connectedTo.setChoices(choices)
# sanity check for empty sat list
if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1:
self.nimConfig.configMode.value = "nothing"
if self.nim.isFBCRoot():
if SystemInfo["HasForceLNBOn"]:
config.misc.forceLnbPower.save()
if SystemInfo["HasForceToneburst"]:
config.misc.forceToneBurst.save()
for x in self["config"].list:
x[1].save()
configfile.save()
def SatfinderMain(session, close=None, **kwargs):
nims = nimmanager.getNimListOfType('DVB-S')
nimList = []
for x in nims:
if nimmanager.getNimConfig(x).configMode.value in ('loopthrough',
'satposdepends',
'nothing'):
continue
if nimmanager.getNimConfig(x).configMode.value == 'advanced' and len(
nimmanager.getSatListForNim(x)) < 1:
continue
nimList.append(x)
if len(nimList) == 0:
session.open(
MessageBox,
_('No satellites configured. Plese check your tuner setup.'),
MessageBox.TYPE_ERROR)
else:
session.openWithCallback(close, Satfinder)
def SatfinderMain(self):
if getBoxType() == '7300s':
self.session.open(MessageBox, _("No Positionerplugin found please Check it!"), MessageBox.TYPE_ERROR)
else:
from Plugins.SystemPlugins.Satfinder.plugin import Satfinder
nims = nimmanager.getNimListOfType("DVB-S")
nimList = []
for x in nims:
if not nimmanager.getNimConfig(x).dvbs.configMode.value in ("loopthrough", "satposdepends", "nothing"):
nimList.append(x)
if len(nimList) == 0:
self.session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
else:
if len(NavigationInstance.instance.getRecordings()) > 0:
self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
else:
if len(nimList) == 1:
self.session.open(Satfinder)
elif len(nimList) > 1:
self.session.open(Satfinder)
def PositionerMain(self):
if getBoxType() == '7300s':
self.session.open(MessageBox, _("No Positionerplugin found please Check it!"), MessageBox.TYPE_ERROR)
else:
from Plugins.SystemPlugins.PositionerSetup.plugin import PositionerSetup, RotorNimSelection
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
self.session.open(MessageBox, _("No positioner capable frontend found."), MessageBox.TYPE_ERROR)
else:
if len(NavigationInstance.instance.getRecordings()) > 0:
self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to configure the positioner."), MessageBox.TYPE_ERROR)
else:
usableNims = []
for x in nimList:
configured_rotor_sats = nimmanager.getRotorSatListForNim(x)
if len(configured_rotor_sats) != 0:
usableNims.append(x)
if len(usableNims) == 1:
self.session.open(PositionerSetup, usableNims[0])
elif len(usableNims) > 1:
self.session.open(RotorNimSelection)
else:
self.session.open(MessageBox, _("No tuner is configured for use with a diseqc positioner!"), MessageBox.TYPE_ERROR)
def unicableconnection(self):
if self.nimConfig.configMode.value == "advanced":
connect_count = 0
dvbs_slots = nimmanager.getNimListOfType('DVB-S')
dvbs_slots_len = len(dvbs_slots)
for x in dvbs_slots:
try:
nim_slot = nimmanager.nim_slots[x]
if nim_slot == self.nimConfig:
self_idx = x
if nim_slot.config.configMode.value == "advanced":
if nim_slot.config.advanced.unicableconnected.value == True:
connect_count += 1
except: pass
print "[Satconfig] %d %d" %(connect_count, dvbs_slots_len)
if connect_count >= dvbs_slots_len:
return False
self.slot_dest_list = []
def checkRecursiveConnect(slot_id):
if slot_id in self.slot_dest_list:
print slot_id
return False
self.slot_dest_list.append(slot_id)
slot_config = nimmanager.nim_slots[slot_id].config
if slot_config.configMode.value == "advanced":
try:
connected = slot_config.advanced.unicableconnected.value
except:
connected = False
if connected == True:
return checkRecursiveConnect(int(slot_config.advanced.unicableconnectedTo.value))
return True
return checkRecursiveConnect(self.slotid)
def unicableconnection(self):
if self.nimConfig.configMode.value == "advanced":
connect_count = 0
dvbs_slots = nimmanager.getNimListOfType('DVB-S')
dvbs_slots_len = len(dvbs_slots)
for x in dvbs_slots:
try:
nim_slot = nimmanager.nim_slots[x]
if nim_slot == self.nimConfig:
self_idx = x
if nim_slot.config.configMode.value == "advanced":
if nim_slot.config.advanced.unicableconnected.value == True:
connect_count += 1
except: pass
print "adenin conections %d %d" %(connect_count, dvbs_slots_len)
if connect_count >= dvbs_slots_len:
return False
self.slot_dest_list = []
def checkRecursiveConnect(slot_id):
if slot_id in self.slot_dest_list:
print slot_id
return False
self.slot_dest_list.append(slot_id)
slot_config = nimmanager.nim_slots[slot_id].config
if slot_config.configMode.value == "advanced":
try:
connected = slot_config.advanced.unicableconnected.value
except:
connected = False
if connected == True:
return checkRecursiveConnect(int(slot_config.advanced.unicableconnectedTo.value))
return True
return checkRecursiveConnect(self.slotid)
def getNimList():
return [x for x in nimmanager.getNimListOfType("DVB-C") if config.Nims[x].configMode.value != "nothing"]
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_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 = nimmanager.getNimListOfType("DVB-C")
self.dvbt_nims = nimmanager.getNimListOfType("DVB-T")
# 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"][:12] == "autobouquet.":
continue
bouquets_list.append((bouquet["filename"], bouquet["name"]))
# build providers configurations
for provider in self.providers.keys():
self.providers_configs[provider] = ConfigYesNo(default = (provider in 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(self.providers[provider]["sections"].keys()) > 1: # only if there's more then 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(self.providers[provider]["sections"].keys())[0] > 1:
makemain_default = "no"
makemain_list = []
makemain_list.append(("yes", _("yes")))
if provider not in providers_tmp_configs:
makemain_default = "yes" # enabled as default
if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain():
makemain_default = "yes"
if self.providers[provider]["protocol"] != "fastscan" and self.providers[provider]["streamtype"] not in ("dvbt"):
makemain_list.append(("hd", _("yes (only HD)")))
makemain_list.append(("ftahd", _("yes (only FTA HD)")))
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:
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 bouquets.keys():
arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"]))
arealist.sort()
if self.providers[provider]["protocol"] == "sky" or self.providers[provider]["protocol"] == "freesat" or self.providers[provider]["streamtype"] in ("dvbc", "dvbt"):
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)
self.createSetup()
self["pleasewait"].hide()
self["actions"].setEnabled(True)
def tryShutdown(self):
self.session.openWithCallback(self.shutdownFailed, TryQuitMainloop, 1)
def shutdownFailed(self, *args):
pass
def askCancel(self):
self.session.openWithCallback(self.askCancelCallback, MessageBox, _("Do you really want to skip the internal disk format?\n\nUsing a non-standard disk format can cause problems and make support more difficult.\n\nIf you skipped the format because the hard disk might need checking, run a filesystem check as soon as you can."), default=False, simple=True)
def askCancelCallback(self, answer):
if answer:
self.close()
config.misc.skip_hdd_startup_format.value = True
config.misc.skip_hdd_startup_format.save()
configfile.save()
#wizardManager.registerWizard(VideoWizard, config.misc.videowizardenabled.value, priority = 0)
#wizardManager.registerWizard(LanguageWizard, config.misc.languageselected.value, priority = -1)
#wizardManager.registerWizard(UserInterfacePositionerWizard, config.misc.firstrun.value, priority = 3)
from Screens.IniTerrestrialLocation import IniTerrestrialLocation, IniEndWizard, config
# If the internal HDD needs to be formatted make the format screen the first screen, and unconditional
if not config.misc.skip_hdd_startup_format.value and needHDDFormat():
wizardManager.registerWizard(StartHDDFormatWizard, True, priority = -10)
wizardManager.registerWizard(StartWizard, config.misc.firstrun.value, priority = 0)
dvbt_nimList = nimmanager.getNimListOfType("DVB-T")
if len(dvbt_nimList) != 0:
wizardManager.registerWizard(IniTerrestrialLocation, config.misc.inifirstrun.value, priority = 1)
wizardManager.registerWizard(IniEndWizard, config.misc.inifirstrun.value, priority = 10) # It always should show as last one
def getNimList():
return [
x for x in nimmanager.getNimListOfType("DVB-C")
if config.Nims[x].configMode.value != "nothing"
]
def doTune(self):
from Screens.Standby import inStandby
transponder = self.providers[self.currentAction]["transponder"]
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
print >> log, "[AutoBouquetsMaker] No DVB-S NIMs founds"
self.showError(_('No DVB-S NIMs founds'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder[
"orbital_position"]
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (
slotid, sat[1])
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print >> log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(
_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print >> log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 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_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 = nimmanager.getNimListOfType("DVB-C")
self.dvbt_nims = nimmanager.getNimListOfType("DVB-T")
# 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"][:12] == "autobouquet.":
continue
bouquets_list.append((bouquet["filename"], bouquet["name"]))
# build providers configurations
for provider in self.providers.keys():
self.providers_configs[provider] = ConfigYesNo(
default=(provider in 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
if len(self.providers[provider]["sections"].keys()
) > 1: # only if there's more then 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
if provider in providers_tmp_configs:
hd_default = providers_tmp_configs[provider].isMakeHD()
fta_default = providers_tmp_configs[provider].isMakeFTA()
self.providers_makehd[provider] = ConfigYesNo(
default=hd_default)
self.providers_makefta[provider] = ConfigYesNo(
default=fta_default)
custom_bouquets_exists = True
if sorted(self.providers[provider]["sections"].keys())[0] > 1:
makemain_default = "no"
makemain_list = []
makemain_list.append(("yes", _("yes")))
if provider not in providers_tmp_configs:
makemain_default = "yes" # enabled as default
if provider in providers_tmp_configs and providers_tmp_configs[
provider].isMakeNormalMain():
makemain_default = "yes"
if self.providers[provider]["protocol"] != "fastscan":
makemain_list.append(("hd", _("yes (only HD)")))
if provider in providers_tmp_configs and providers_tmp_configs[
provider].isMakeHDMain():
makemain_default = "hd"
if len(bouquets_list) > 0:
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 bouquets.keys():
arealist.append(
(bouquet,
self.providers[provider]["bouquets"][bouquet]["name"]))
arealist.sort()
if self.providers[provider]["protocol"] == "sky" or self.providers[
provider]["protocol"] == "freesat" or self.providers[
provider]["streamtype"] in ("dvbc", "dvbt"):
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)
self.createSetup()
self["pleasewait"].hide()
self["actions"].setEnabled(True)
def CableScanMain(session, **kwargs):
nimlist = nimmanager.getNimListOfType("DVB-C")
if nimlist:
Session.open(CableScanScreen, nimlist)
else:
Session.open(MessageBox, _("No cable tuner found!"), type=MessageBox.TYPE_ERROR)
def doTune(self):
from Screens.Standby import inStandby
transponder = self.providers[self.currentAction]["transponder"]
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
print>>log, "[AutoBouquetsMaker] No DVB-S NIMs founds"
self.showError(_('No DVB-S NIMs founds'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print>>log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
print>>log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"]
current_slotid = -1
if self.rawchannel:
del(self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1])
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print>>log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print>>log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print>>log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print>>log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 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 = []
# make config test for ATV Multituner
self.legacy = True
for slot in nimmanager.nim_slots:
if slot.canBeCompatible("DVB-S"):
try:
slot.config.dvbs
self.legacy = False
except:
self.legacy = True
break
# 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 = []
for nim in nimmanager.nim_slots:
if not self.legacy:
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)
else:
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)
# 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 self.providers.keys():
self.providers_configs[provider] = ConfigYesNo(default = (provider not in self.dependents_list and provider in 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(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(self.providers[provider]["sections"].keys())[0] > 1:
makemain_default = "no"
makemain_list = [("yes", _("yes"))]
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" # FTA HD only as default
elif provider not in providers_tmp_configs:
makemain_default = "yes" # enabled as default
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 bouquets.keys():
arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"]))
arealist.sort()
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 updateAndReadServicesFastscan(self, namespace, transponders, servicehacks, transport_stream_id_list, logical_channel_number_dict):
print>>log, "[DvbScanner] Reading services..."
fd = dvbreader.open(self.demuxer_device, self.fastscan_pid, self.fastscan_table_id, 0xff, self.frontend)
if fd < 0:
print>>log, "[DvbScanner] Cannot open the demuxer"
return None
fastscan_section_version = -1
fastscan_section_id = -1
fastscan_sections_read = []
fastscan_sections_count = 0
fastscan_content = []
timeout = datetime.datetime.now()
timeout += datetime.timedelta(0, self.TIMEOUT_SEC)
while True:
if datetime.datetime.now() > timeout:
print>>log, "[DvbScanner] Timed out"
break
section = dvbreader.read_fastscan(fd, self.fastscan_table_id)
if section is None:
time.sleep(0.1) # no data.. so we wait a bit
continue
if section["header"]["table_id"] == self.fastscan_table_id:
if (section["header"]["version_number"] != fastscan_section_version
or section["header"]["fastscan_id"] != fastscan_section_id):
fastscan_section_version = section["header"]["version_number"]
fastscan_section_id = section["header"]["fastscan_id"]
fastscan_sections_read = []
fastscan_content = []
fastscan_sections_count = section["header"]["last_section_number"] + 1
if section["header"]["section_number"] not in fastscan_sections_read:
fastscan_sections_read.append(section["header"]["section_number"])
fastscan_content += section["content"]
if len(fastscan_sections_read) == fastscan_sections_count:
break
dvbreader.close(fd)
# to ignore services on not configured satellites
if config.autobouquetsmaker.skipservices.value:
from Components.NimManager import nimmanager
nims = nimmanager.getNimListOfType("DVB-S")
orbitals_configured = []
for nim in nims:
sats = nimmanager.getSatListForNim(nim)
for sat in sats:
if sat[0] not in orbitals_configured:
orbitals_configured.append(sat[0])
service_count = 0
tmp_services_dict = {}
for section in fastscan_content:
service = section
key = "%x:%x:%x" % (service["transport_stream_id"], service["original_network_id"], service["service_id"])
if key not in logical_channel_number_dict:
continue
if logical_channel_number_dict[key]["visible_service_flag"] == 0:
continue
if not hasattr(service, "free_ca"):
service["free_ca"] = 1
if not hasattr(service, "namespace"):
try:
service["namespace"] = service["namespace"] = logical_channel_number_dict[key]["transponder"]["namespace"]
except:
service["namespace"] = namespace
if not hasattr(service, "flags"):
service["flags"] = 0
service["number"] = logical_channel_number_dict[key]["logical_channel_number"]
service["orbital_position"] = service["namespace"] / (16**4)
if key in tmp_services_dict:
tmp_services_dict[key]["numbers"].append(service["number"])
else:
service["numbers"] = [service["number"]]
tmp_services_dict[key] = service
service_count += 1
print>>log, "[DvbScanner] Read %d services" % service_count
video_services = {}
radio_services = {}
service_extra_count = 0
services_without_transponders = 0
for key in self.LCN_order(tmp_services_dict):
service = tmp_services_dict[key]
if config.autobouquetsmaker.skipservices.value and service["orbital_position"] not in orbitals_configured:
continue
if len(servicehacks) > 0:
skip = False
exec(servicehacks)
if skip:
continue
tpkey = "%x:%x:%x" % (service["namespace"], service["transport_stream_id"], service["original_network_id"])
if tpkey not in transponders:
services_without_transponders += 1
continue
transponders[tpkey]["services"][service["service_id"]] = service
service_extra_count += 1
if service["service_type"] in DvbScanner.VIDEO_ALLOWED_TYPES or service["service_type"] in DvbScanner.INTERACTIVE_ALLOWED_TYPES:
for number in service["numbers"]:
if number not in video_services:
video_services[number] = service
else:
for number in service["numbers"]:
if number not in radio_services:
radio_services[number] = service
print>>log, "[DvbScanner] %d valid services" % service_extra_count
if services_without_transponders:
print>>log, "[DvbScanner] %d services omitted as there is no corresponding transponder" % services_without_transponders
return {
"video": video_services,
"radio": radio_services
}
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:
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 self.providers.keys():
self.providers_configs[provider] = ConfigYesNo(default = (provider not in self.dependents_list and provider in 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(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(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" # FTA HD only as default
elif provider not in providers_tmp_configs:
makemain_default = "yes" # enabled as default
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 bouquets.keys():
arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"]))
arealist.sort()
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)
#wizardManager.registerWizard(VideoWizard, config.misc.videowizardenabled.value, priority = 0)
#wizardManager.registerWizard(LanguageWizard, config.misc.languageselected.value, priority = -1)
#wizardManager.registerWizard(UserInterfacePositionerWizard, config.misc.firstrun.value, priority = 3)
from Screens.IniTerrestrialLocation import IniTerrestrialLocation, IniEndWizard, config
# If the internal HDD needs to be formatted make the format screen the first screen, and unconditional
if not config.misc.skip_hdd_startup_format.value and needHDDFormat():
wizardManager.registerWizard(StartHDDFormatWizard, True, priority=-10)
wizardManager.registerWizard(StartWizard,
config.misc.firstrun.value,
priority=0)
# Terrestrial Location Wizard Screen
dvbt_nimList = nimmanager.getNimListOfType("DVB-T")
if len(dvbt_nimList) != 0:
wizardManager.registerWizard(IniTerrestrialLocation,
config.misc.inifirstrun.value,
priority=1)
# IPTV Channel List downloader for T-POD
if SystemInfo["IPTVSTB"]:
from os import path
if path.exists(
"/usr/lib/enigma2/python/Plugins/Extensions/RemoteIPTVClient"):
from Plugins.Extensions.RemoteIPTVClient.plugin import RemoteTunerScanner
wizardManager.registerWizard(
RemoteTunerScanner, config.misc.inifirstrun.value,
priority=2) # It always should show as last one
