projects / vuplus_dvbapp / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge commit 'dm/experimental' into test branch
[vuplus_dvbapp] / lib / python / Screens / NetworkSetup.py
diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py
index 908a615..32b9f54 100755 (executable)
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -11,7 +11,7 @@ from Components.Sources.List import List
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing, ConfigBoolean
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
@@ -42,11 +42,6 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                self["key_blue"] = StaticText("")
                self["introduction"] = StaticText(self.edittext)
                
                self["key_blue"] = StaticText("")
                self["introduction"] = StaticText(self.edittext)
                
-               self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
-               
-               if not self.adapters:
-                       self.onFirstExecBegin.append(self.NetworkFallback)
-                       
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.close, _("exit network interface list")),
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.close, _("exit network interface list")),
@@ -65,6 +60,14 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
                        })
 
                        "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
                        })
 
+               self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
+
+               if not self.adapters:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getConfiguredAdapters()]
+
+               if len(self.adapters) == 0:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
+
                self.list = []
                self["list"] = List(self.list)
                self.updateList()
                self.list = []
                self["list"] = List(self.list)
                self.updateList()
@@ -80,14 +83,14 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                description = None
                interfacepng = None
 
                description = None
                interfacepng = None
 
-               if iface in iNetwork.lan_interfaces:
+               if not iNetwork.isWirelessInterface(iface):
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
                        elif active is False:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
                        else:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
                        elif active is False:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
                        else:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
-               elif iface in iNetwork.wlan_interfaces:
+               elif iNetwork.isWirelessInterface(iface):
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
                        elif active is False:
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
                        elif active is False:
@@ -132,19 +135,16 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        fp.close()
                        default_gw = result
                                        
                        fp.close()
                        default_gw = result
                                        
-               if len(self.adapters) == 0: # no interface available => display only eth0
-                       self.list.append(self.buildInterfaceList("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
-               else:
-                       for x in self.adapters:
-                               if x[1] == default_gw:
-                                       default_int = True
-                               else:
-                                       default_int = False
-                               if iNetwork.getAdapterAttribute(x[1], 'up') is True:
-                                       active_int = True
-                               else:
-                                       active_int = False
-                               self.list.append(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
+               for x in self.adapters:
+                       if x[1] == default_gw:
+                               default_int = True
+                       else:
+                               default_int = False
+                       if iNetwork.getAdapterAttribute(x[1], 'up') is True:
+                               active_int = True
+                       else:
+                               active_int = False
+                       self.list.append(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
                
                if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
                        self["key_blue"].setText(_("NetworkWizard"))
                
                if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
                        self["key_blue"].setText(_("NetworkWizard"))
@@ -179,22 +179,6 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                else:
                        self.updateList()
 
                else:
                        self.updateList()
 
-       def NetworkFallback(self):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               else:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-
-       def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
-               else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
-
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopRestartConsole()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopRestartConsole()
@@ -312,18 +296,17 @@ class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
 
 
 class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
 
 
 class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
-       def __init__(self, session, networkinfo, essid=None, aplist=None):
+       def __init__(self, session, networkinfo, essid=None):
                Screen.__init__(self, session)
                HelpableScreen.__init__(self)
                self.session = session
                if isinstance(networkinfo, (list, tuple)):
                        self.iface = networkinfo[0]
                        self.essid = networkinfo[1]
                Screen.__init__(self, session)
                HelpableScreen.__init__(self)
                self.session = session
                if isinstance(networkinfo, (list, tuple)):
                        self.iface = networkinfo[0]
                        self.essid = networkinfo[1]
-                       self.aplist = networkinfo[2]
                else:
                        self.iface = networkinfo
                        self.essid = essid
                else:
                        self.iface = networkinfo
                        self.essid = essid
-                       self.aplist = aplist
+                       
                self.extended = None
                self.applyConfigRef = None
                self.finished_cb = None
                self.extended = None
                self.applyConfigRef = None
                self.finished_cb = None
@@ -414,62 +397,36 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                self.gatewayEntry = None
                self.hiddenSSID = None
                self.wlanSSID = None
                self.gatewayEntry = None
                self.hiddenSSID = None
                self.wlanSSID = None
-               self.encryptionEnabled = None
-               self.encryptionKey = None
+               self.encryption = None
                self.encryptionType = None
                self.encryptionType = None
-               self.nwlist = None
+               self.encryptionKey = None
                self.encryptionlist = None
                self.weplist = None
                self.wsconfig = None
                self.default = None
 
                self.encryptionlist = None
                self.weplist = None
                self.wsconfig = None
                self.default = None
 
-               if self.iface in iNetwork.wlan_interfaces:
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
-                       self.w = Wlan(self.iface)
+               if iNetwork.isWirelessInterface(self.iface):
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
                        self.ws = wpaSupplicant()
                        self.encryptionlist = []
                        self.ws = wpaSupplicant()
                        self.encryptionlist = []
+                       self.encryptionlist.append(("Unencrypted", _("Unencrypted")))
                        self.encryptionlist.append(("WEP", _("WEP")))
                        self.encryptionlist.append(("WPA", _("WPA")))
                        self.encryptionlist.append(("WEP", _("WEP")))
                        self.encryptionlist.append(("WPA", _("WPA")))
-                       self.encryptionlist.append(("WPA2", _("WPA2")))
                        self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
                        self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+                       self.encryptionlist.append(("WPA2", _("WPA2")))
                        self.weplist = []
                        self.weplist.append("ASCII")
                        self.weplist.append("HEX")
                        self.weplist = []
                        self.weplist.append("ASCII")
                        self.weplist.append("HEX")
-                       if self.aplist is not None:
-                               self.nwlist = self.aplist
-                               self.nwlist.sort(key = lambda x: x[0])
-                       else:
-                               self.nwlist = []
-                               self.aps = None
-                               try:
-                                       self.aps = self.w.getNetworkList()
-                                       if self.aps is not None:
-                                               for ap in self.aps:
-                                                       a = self.aps[ap]
-                                                       if a['active']:
-                                                               if a['essid'] != '':
-                                                                       self.nwlist.append((a['essid'],a['essid']))
-                                       self.nwlist.sort(key = lambda x: x[0])
-                               except:
-                                       self.nwlist.append(("No Networks found",_("No Networks found")))
-
-                       self.wsconfig = self.ws.loadConfig()
-                       if self.essid is not None: # ssid from wlan scan
-                               self.default = self.essid
-                       else:
-                               self.default = self.wsconfig['ssid']
 
 
-                       if "hidden..." not in self.nwlist:
-                               self.nwlist.append(("hidden...",_("enter hidden network SSID")))
-                       if self.default not in self.nwlist:
-                               self.nwlist.append((self.default,self.default))
-                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
-                       config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
+                       self.wsconfig = self.ws.loadConfig(self.iface)
+                       if self.essid is None:
+                               self.essid = self.wsconfig['ssid']
 
 
-                       config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
-                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
-                       config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
-                       config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = self.wsconfig['hiddenessid']))
+                       config.plugins.wlan.essid = NoSave(ConfigText(default = self.essid, visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.encryption = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption'] ))
+                       config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['wepkeytype'] ))
+                       config.plugins.wlan.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
 
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
 
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
@@ -502,6 +459,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 
                        self.extended = None
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 
                        self.extended = None
+                       self.configStrings = None
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
@@ -509,30 +467,21 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                                self.extended = callFnc
                                                if p.__call__.has_key("configStrings"):
                                                        self.configStrings = p.__call__["configStrings"]
                                                self.extended = callFnc
                                                if p.__call__.has_key("configStrings"):
                                                        self.configStrings = p.__call__["configStrings"]
-                                               else:
-                                                       self.configStrings = None
-                                               if config.plugins.wlan.essid.value == 'hidden...':
-                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
-                                                       self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
-                                                       self.list.append(self.hiddenSSID)
-                                               else:
-                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
-                                               self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
-                                               self.list.append(self.encryptionEnabled)
-                                               
-                                               if config.plugins.wlan.encryption.enabled.value:
-                                                       self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
-                                                       self.list.append(self.encryptionType)
-                                                       if config.plugins.wlan.encryption.type.value == 'WEP':
-                                                               self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
-                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
-                                                               self.list.append(self.encryptionKey)
-                                                       else:
-                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
-                                                               self.list.append(self.encryptionKey)
 
 
+                                               self.hiddenSSID = getConfigListEntry(_("Hidden network"), config.plugins.wlan.hiddenessid)
+                                               self.list.append(self.hiddenSSID)
+                                               self.wlanSSID = getConfigListEntry(_("Networkname (SSID)"), config.plugins.wlan.essid)
+                                               self.list.append(self.wlanSSID)
+                                               self.encryption = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption)
+                                               self.list.append(self.encryption)                                               
+
+                                               self.encryptionType = getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.wepkeytype)
+                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.psk)
+                                               
+                                               if config.plugins.wlan.encryption.value != "Unencrypted":
+                                                       if config.plugins.wlan.encryption.value == 'WEP':
+                                                               self.list.append(self.encryptionType)
+                                                       self.list.append(self.encryptionKey)
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
@@ -546,12 +495,8 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        self.createSetup()
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
                        self.createSetup()
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
-               if self.iface in iNetwork.wlan_interfaces:
-                       if self["config"].getCurrent() == self.wlanSSID:
-                               self.createSetup()
-                       if self["config"].getCurrent() == self.encryptionEnabled:
-                               self.createSetup()
-                       if self["config"].getCurrent() == self.encryptionType:
+               if iNetwork.isWirelessInterface(self.iface):
+                       if self["config"].getCurrent() == self.encryption:
                                self.createSetup()
 
        def keyLeft(self):
                                self.createSetup()
 
        def keyLeft(self):
@@ -576,7 +521,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                if (ret == True):               
                        num_configured_if = len(iNetwork.getConfiguredAdapters())
                        if num_configured_if >= 1:
                if (ret == True):               
                        num_configured_if = len(iNetwork.getConfiguredAdapters())
                        if num_configured_if >= 1:
-                               if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
+                               if self.iface in iNetwork.getConfiguredAdapters():      
                                        self.applyConfig(True)
                                else:
                                        self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
                                        self.applyConfig(True)
                                else:
                                        self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
@@ -594,11 +539,15 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                if interface == self.iface:
                                        continue
                                iNetwork.setAdapterAttribute(interface, "up", False)
                                if interface == self.iface:
                                        continue
                                iNetwork.setAdapterAttribute(interface, "up", False)
-                               iNetwork.deactivateInterface(interface)
-                               self.applyConfig(True)
+                       iNetwork.deactivateInterface(configuredInterfaces,self.deactivateSecondInterfaceCB)
+
+       def deactivateSecondInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfig(True)
 
        def applyConfig(self, ret = False):
                if (ret == True):
 
        def applyConfig(self, ret = False):
                if (ret == True):
+                       self.applyConfigRef = None
                        iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
@@ -607,17 +556,33 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
                        else:
                                iNetwork.removeAdapterAttribute(self.iface, "gateway")
                                iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
                        else:
                                iNetwork.removeAdapterAttribute(self.iface, "gateway")
-                       if self.extended is not None and self.configStrings is not None:
+
+                       if (self.extended is not None and self.configStrings is not None):
                                iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
                                iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
-                               self.ws.writeConfig()
+                               self.ws.writeConfig(self.iface)
+                               
                        if self.activateInterfaceEntry.value is False:
                        if self.activateInterfaceEntry.value is False:
-                               iNetwork.deactivateInterface(self.iface)
-                       iNetwork.writeNetworkConfig()
-                       iNetwork.restartNetwork(self.applyConfigDataAvail)
-                       self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                               iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       else:
+                               if self.oldInterfaceState is False:
+                                       iNetwork.activateInterface(self.iface,self.deactivateInterfaceCB)
+                               else:
+                                       iNetwork.deactivateInterface(self.iface,self.activateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                else:
                        self.keyCancel()
 
                else:
                        self.keyCancel()
 
+       def deactivateInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfigDataAvail(True)
+
+       def activateInterfaceCB(self, data):
+               if data is True:
+                       iNetwork.activateInterface(self.iface,self.applyConfigDataAvail)
+
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
@@ -675,10 +640,10 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                
        def hideInputHelp(self):
                current = self["config"].getCurrent()
                
        def hideInputHelp(self):
                current = self["config"].getCurrent()
-               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+               if current == self.wlanSSID:
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
-               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.value is not "Unencrypted":
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
 
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
 
@@ -703,7 +668,8 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your STB will restart after pressing OK on your remote control.")
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your STB will restart after pressing OK on your remote control.")
-               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
+               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")
+               self.missingwlanplugintxt = _("The wireless LAN plugin is not installed!\nPlease install it.")
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",
                        {
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",
                        {
@@ -739,30 +705,39 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
+
+       def queryWirelessDevice(self,iface):
+               try:
+                       from pythonwifi.iwlibs import Wireless
+                       import errno
+               except ImportError:
+                       return False
+               else:
+                       try:
+                               ifobj = Wireless(iface) # a Wireless NIC Object
+                               wlanresponse = ifobj.getAPaddr()
+                       except IOError, (error_no, error_str):
+                               if error_no in (errno.EOPNOTSUPP, errno.ENODEV, errno.EPERM):
+                                       return False
+                               else:
+                                       print "error: ",error_no,error_str
+                                       return True
+                       else:
+                               return True
+
        def ok(self):
                self.cleanup()
                if self["menulist"].getCurrent()[1] == 'edit':
        def ok(self):
                self.cleanup()
                if self["menulist"].getCurrent()[1] == 'edit':
-                       if self.iface in iNetwork.wlan_interfaces:
+                       if iNetwork.isWirelessInterface(self.iface):
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                                       from pythonwifi.iwlibs import Wireless
                                except ImportError:
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:
                                else:
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       try:
-                                               self.wlanresponse = ifobj.getAPaddr()
-                                       except IOError:
-                                               self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse:
-                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
-                                               else:
-                                                       # Display Wlan not available Message
-                                                       self.showErrorMessage()
+                                       if self.queryWirelessDevice(self.iface):
+                                               self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                        else:
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                if self["menulist"].getCurrent()[1] == 'test':
                        else:
                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                if self["menulist"].getCurrent()[1] == 'test':
@@ -772,45 +747,23 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if self["menulist"].getCurrent()[1] == 'scanwlan':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                if self["menulist"].getCurrent()[1] == 'scanwlan':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                               from pythonwifi.iwlibs import Wireless
                        except ImportError:
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                        else:
                        else:
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               try:
-                                       self.wlanresponse = ifobj.getAPaddr()
-                               except IOError:
-                                       self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse:
-                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                               self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
-                                       else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                               if self.queryWirelessDevice(self.iface):
+                                       self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                else:
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                               from pythonwifi.iwlibs import Wireless
                        except ImportError:
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
-                       else:   
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               try:
-                                       self.wlanresponse = ifobj.getAPaddr()
-                               except IOError:
-                                       self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse:
-                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
-                                       else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+                       else:
+                               if self.queryWirelessDevice(self.iface):
+                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                else:
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'lanrestart':
                        self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                if self["menulist"].getCurrent()[1] == 'openwizard':
                if self["menulist"].getCurrent()[1] == 'lanrestart':
                        self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                if self["menulist"].getCurrent()[1] == 'openwizard':
@@ -866,7 +819,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
                
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
                
-               if self.iface in iNetwork.wlan_interfaces:
+               if iNetwork.isWirelessInterface(self.iface):
                        try:
                                from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        except:
                        try:
                                from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        except:
@@ -916,27 +869,16 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def AdapterSetupClosed(self, *ret):
                if ret is not None and len(ret):
 
        def AdapterSetupClosed(self, *ret):
                if ret is not None and len(ret):
-                       if ret[0] == 'ok' and (self.iface in iNetwork.wlan_interfaces) and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                       if ret[0] == 'ok' and (iNetwork.isWirelessInterface(self.iface) and iNetwork.getAdapterAttribute(self.iface, "up") is True):
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                                       from pythonwifi.iwlibs import Wireless
                                except ImportError:
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:   
                                else:   
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       try:
-                                               self.wlanresponse = ifobj.getAPaddr()
-                                       except IOError:
-                                               self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse:
-                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
-                                               else:
-                                                       # Display Wlan not available Message
-                                                       self.showErrorMessage()
+                                       if self.queryWirelessDevice(self.iface):
+                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                        else:
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.updateStatusbar()
                else:
                        else:
                                self.updateStatusbar()
                else:
@@ -950,7 +892,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def WlanScanClosed(self,*ret):
                if ret[0] is not None:
 
        def WlanScanClosed(self,*ret):
                if ret[0] is not None:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
+                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0])
                else:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        iStatus.stopWlanConsole()
                else:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        iStatus.stopWlanConsole()
@@ -995,6 +937,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
+               iNetwork.stopActivateInterfaceConsole()
                iNetwork.stopPingConsole()
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                iNetwork.stopPingConsole()
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
@@ -1008,7 +951,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if data is not None:
                        if data is True:
                                if status is not None:
                if data is not None:
                        if data is True:
                                if status is not None:
-                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                       if status[self.iface]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
                                                self.LinkState = False
                                                self["statuspic"].setPixmapNum(1)
                                                self["statuspic"].show()
                                                self.LinkState = False
                                                self["statuspic"].setPixmapNum(1)
                                                self["statuspic"].show()
@@ -1376,7 +1319,7 @@ class NetworkAdapterTest(Screen):
 
        def LinkStatedataAvail(self,data):
                self.output = data.strip()
 
        def LinkStatedataAvail(self,data):
                self.output = data.strip()
-               result = self.output.split('\n')
+               result = self.output.splitlines()
                pattern = re_compile("Link detected: yes")
                for item in result:
                        if re_search(pattern, item):
                pattern = re_compile("Link detected: yes")
                for item in result:
                        if re_search(pattern, item):
@@ -1430,7 +1373,7 @@ class NetworkAdapterTest(Screen):
                if data is not None:
                        if data is True:
                                if status is not None:
                if data is not None:
                        if data is True:
                                if status is not None:
-                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                       if status[self.iface]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
                                                self["Network"].setForegroundColorNum(1)
                                                self["Network"].setText(_("disconnected"))
                                                self["NetworkInfo_Check"].setPixmapNum(1)
                                                self["Network"].setForegroundColorNum(1)
                                                self["Network"].setText(_("disconnected"))
                                                self["NetworkInfo_Check"].setPixmapNum(1)
Unnamed repository; edit this file 'description' to name the repository.