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 __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 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 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 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 __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 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 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 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 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