Example 1 with GwtWifiRadioMode
use of org.eclipse.kura.web.shared.model.GwtWifiRadioMode in project kura by eclipse.
the class GwtNetworkServiceImpl method privateFindNetInterfaceConfigurations.
@SuppressWarnings({ "unchecked", "rawtypes" })
private List<GwtNetInterfaceConfig> privateFindNetInterfaceConfigurations() throws GwtKuraException {
s_logger.debug("Starting");
List<GwtNetInterfaceConfig> gwtNetConfigs = new ArrayList<GwtNetInterfaceConfig>();
NetworkAdminService nas = null;
try {
nas = ServiceLocator.getInstance().getService(NetworkAdminService.class);
} catch (Throwable t) {
s_logger.warn("Exception", t);
return gwtNetConfigs;
}
ModemManagerService modemManagerService = null;
try {
modemManagerService = ServiceLocator.getInstance().getService(ModemManagerService.class);
} catch (Throwable t) {
s_logger.warn("{ModemManagerService} Exception", t);
}
WifiClientMonitorService wifiClientMonitorService = null;
try {
wifiClientMonitorService = ServiceLocator.getInstance().getService(WifiClientMonitorService.class);
} catch (Throwable t) {
s_logger.warn("{WifiClientMonitorService} Exception", t);
}
try {
GwtNetInterfaceConfig gwtNetConfig = null;
for (NetInterfaceConfig<? extends NetInterfaceAddressConfig> netIfConfig : nas.getNetworkInterfaceConfigs()) {
s_logger.debug("Getting config for {} with type {}", netIfConfig.getName(), netIfConfig.getType());
s_logger.debug("Interface State: {}", netIfConfig.getState());
if (netIfConfig.getType() == NetInterfaceType.WIFI) {
gwtNetConfig = new GwtWifiNetInterfaceConfig();
} else if (netIfConfig.getType() == NetInterfaceType.MODEM) {
gwtNetConfig = new GwtModemInterfaceConfig();
((GwtModemInterfaceConfig) gwtNetConfig).setModemId(((ModemInterface) netIfConfig).getModemIdentifier());
((GwtModemInterfaceConfig) gwtNetConfig).setManufacturer(((ModemInterface) netIfConfig).getManufacturer());
((GwtModemInterfaceConfig) gwtNetConfig).setModel(((ModemInterface) netIfConfig).getModel());
List<String> technologyList = new ArrayList<String>();
List<ModemTechnologyType> technologyTypes = ((ModemInterface) netIfConfig).getTechnologyTypes();
if (technologyTypes != null) {
for (ModemTechnologyType techType : technologyTypes) {
technologyList.add(techType.name());
}
}
((GwtModemInterfaceConfig) gwtNetConfig).setNetworkTechnology(technologyList);
} else {
gwtNetConfig = new GwtNetInterfaceConfig();
gwtNetConfig.setHwRssi("N/A");
}
gwtNetConfig.setName(netIfConfig.getName());
gwtNetConfig.setHwName(netIfConfig.getName());
if (netIfConfig.getType() != null) {
gwtNetConfig.setHwType(netIfConfig.getType().name());
}
if (netIfConfig.getState() != null) {
gwtNetConfig.setHwState(netIfConfig.getState().name());
}
s_logger.debug("MAC: {}", NetUtil.hardwareAddressToString(netIfConfig.getHardwareAddress()));
gwtNetConfig.setHwAddress(NetUtil.hardwareAddressToString(netIfConfig.getHardwareAddress()));
gwtNetConfig.setHwDriver(netIfConfig.getDriver());
gwtNetConfig.setHwDriverVersion(netIfConfig.getDriverVersion());
gwtNetConfig.setHwFirmware(netIfConfig.getFirmwareVersion());
gwtNetConfig.setHwMTU(netIfConfig.getMTU());
if (netIfConfig.getUsbDevice() != null) {
gwtNetConfig.setHwUsbDevice(netIfConfig.getUsbDevice().getUsbDevicePath());
} else {
gwtNetConfig.setHwUsbDevice("N/A");
}
List<? extends NetInterfaceAddressConfig> addressConfigs = netIfConfig.getNetInterfaceAddresses();
if (addressConfigs != null && !addressConfigs.isEmpty()) {
for (NetInterfaceAddressConfig addressConfig : addressConfigs) {
// current status - not configuration!
if (addressConfig.getAddress() != null) {
s_logger.debug("current address: {}", addressConfig.getAddress().getHostAddress());
}
if (addressConfig.getNetworkPrefixLength() >= 0 && addressConfig.getNetworkPrefixLength() <= 32) {
s_logger.debug("current prefix length: {}", addressConfig.getNetworkPrefixLength());
}
if (addressConfig.getNetmask() != null) {
s_logger.debug("current netmask: {}", addressConfig.getNetmask().getHostAddress());
}
List<NetConfig> netConfigs = addressConfig.getConfigs();
if (netConfigs != null && !netConfigs.isEmpty()) {
boolean isNatEnabled = false;
boolean isDhcpServerEnabled = false;
for (NetConfig netConfig : netConfigs) {
if (netConfig instanceof NetConfigIP4) {
s_logger.debug("Setting up NetConfigIP4 with status {}", ((NetConfigIP4) netConfig).getStatus().toString());
// we are enabled - for LAN or WAN?
if (((NetConfigIP4) netConfig).getStatus() == NetInterfaceStatus.netIPv4StatusEnabledLAN) {
gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusEnabledLAN.name());
} else if (((NetConfigIP4) netConfig).getStatus() == NetInterfaceStatus.netIPv4StatusEnabledWAN) {
gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusEnabledWAN.name());
} else {
gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusDisabled.name());
}
if (((NetConfigIP4) netConfig).isDhcp()) {
gwtNetConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeDHCP.name());
// since DHCP - populate current data
if (addressConfig.getAddress() != null) {
gwtNetConfig.setIpAddress(addressConfig.getAddress().getHostAddress());
} else {
gwtNetConfig.setIpAddress("");
}
if (addressConfig.getNetworkPrefixLength() >= 0 && addressConfig.getNetworkPrefixLength() <= 32) {
gwtNetConfig.setSubnetMask(NetworkUtil.getNetmaskStringForm(addressConfig.getNetworkPrefixLength()));
} else {
if (addressConfig.getNetmask() != null) {
gwtNetConfig.setSubnetMask(addressConfig.getNetmask().getHostAddress());
} else {
gwtNetConfig.setSubnetMask("");
}
}
if (addressConfig.getGateway() != null) {
gwtNetConfig.setGateway(addressConfig.getGateway().getHostAddress());
} else {
gwtNetConfig.setGateway("");
}
// DHCP supplied DNS servers
StringBuffer sb = new StringBuffer();
List<? extends IPAddress> dnsServers = addressConfig.getDnsServers();
if (dnsServers != null && !dnsServers.isEmpty()) {
String sep = "";
for (IPAddress dnsServer : dnsServers) {
sb.append(sep).append(dnsServer.getHostAddress());
sep = "\n";
}
s_logger.debug("DNS Servers: {}", sb);
gwtNetConfig.setReadOnlyDnsServers(sb.toString());
} else {
s_logger.debug("DNS Servers: [empty String]");
gwtNetConfig.setReadOnlyDnsServers("");
}
} else {
gwtNetConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeManual.name());
// TODO - should we throw an error if current state doesn't match configuration?
if (((NetConfigIP4) netConfig).getAddress() != null) {
gwtNetConfig.setIpAddress(((NetConfigIP4) netConfig).getAddress().getHostAddress());
} else {
gwtNetConfig.setIpAddress("");
}
if (((NetConfigIP4) netConfig).getSubnetMask() != null) {
gwtNetConfig.setSubnetMask(((NetConfigIP4) netConfig).getSubnetMask().getHostAddress());
} else {
gwtNetConfig.setSubnetMask("");
}
if (((NetConfigIP4) netConfig).getGateway() != null) {
s_logger.debug("Gateway for {} is: {}", netIfConfig.getName(), ((NetConfigIP4) netConfig).getGateway().getHostAddress());
gwtNetConfig.setGateway(((NetConfigIP4) netConfig).getGateway().getHostAddress());
} else {
gwtNetConfig.setGateway("");
}
}
// Custom DNS servers
StringBuffer sb = new StringBuffer();
List<IP4Address> dnsServers = ((NetConfigIP4) netConfig).getDnsServers();
if (dnsServers != null && !dnsServers.isEmpty()) {
for (IP4Address dnsServer : dnsServers) {
if (!dnsServer.getHostAddress().equals("127.0.0.1")) {
sb.append(' ').append(dnsServer.getHostAddress());
}
}
s_logger.debug("DNS Servers: {}", sb);
gwtNetConfig.setDnsServers(sb.toString().trim());
} else {
s_logger.debug("DNS Servers: [empty String]");
gwtNetConfig.setDnsServers("");
}
// Search domains
sb = new StringBuffer();
List<IP4Address> winsServers = ((NetConfigIP4) netConfig).getWinsServers();
if (winsServers != null && !winsServers.isEmpty()) {
for (IP4Address winServer : winsServers) {
sb.append(winServer.getHostAddress());
sb.append("\n");
}
s_logger.debug("Search Domains: {}", sb);
gwtNetConfig.setSearchDomains(sb.toString());
} else {
s_logger.debug("Search Domains: [empty String]");
gwtNetConfig.setSearchDomains("");
}
}
// config
if (netConfig instanceof WifiConfig) {
s_logger.debug("Setting up WifiConfigIP4");
WifiConfig wifiConfig = (WifiConfig) netConfig;
GwtWifiConfig gwtWifiConfig = new GwtWifiConfig();
// mode
if (wifiConfig.getMode() == WifiMode.MASTER) {
gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name());
// set as the access point config for this interface
((GwtWifiNetInterfaceConfig) gwtNetConfig).setAccessPointWifiConfig(gwtWifiConfig);
} else if (wifiConfig.getMode() == WifiMode.INFRA) {
gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeStation.name());
// set as the station config for this interface
((GwtWifiNetInterfaceConfig) gwtNetConfig).setStationWifiConfig(gwtWifiConfig);
} else if (wifiConfig.getMode() == WifiMode.ADHOC) {
gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAdHoc.name());
// set as the adhoc config for this interface
((GwtWifiNetInterfaceConfig) gwtNetConfig).setAdhocWifiConfig(gwtWifiConfig);
}
// ssid
gwtWifiConfig.setWirelessSsid(wifiConfig.getSSID());
// driver
gwtWifiConfig.setDriver(wifiConfig.getDriver());
// security
if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA) {
gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA.name());
} else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA2) {
gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA2.name());
} else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA_WPA2) {
gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA_WPA2.name());
} else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WEP) {
gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWEP.name());
} else {
gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityNONE.name());
}
if (wifiConfig.getPairwiseCiphers() == WifiCiphers.CCMP_TKIP) {
gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name());
} else if (wifiConfig.getPairwiseCiphers() == WifiCiphers.TKIP) {
gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_TKIP.name());
} else if (wifiConfig.getPairwiseCiphers() == WifiCiphers.CCMP) {
gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_CCMP.name());
}
if (wifiConfig.getGroupCiphers() == WifiCiphers.CCMP_TKIP) {
gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name());
} else if (wifiConfig.getGroupCiphers() == WifiCiphers.TKIP) {
gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_TKIP.name());
} else if (wifiConfig.getGroupCiphers() == WifiCiphers.CCMP) {
gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_CCMP.name());
}
// bgscan
WifiBgscan wifiBgscan = wifiConfig.getBgscan();
if (wifiBgscan != null) {
if (wifiBgscan.getModule() == WifiBgscanModule.NONE) {
gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_NONE.name());
} else if (wifiBgscan.getModule() == WifiBgscanModule.SIMPLE) {
gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_SIMPLE.name());
} else if (wifiBgscan.getModule() == WifiBgscanModule.LEARN) {
gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_LEARN.name());
}
gwtWifiConfig.setBgscanRssiThreshold(wifiBgscan.getRssiThreshold());
gwtWifiConfig.setBgscanShortInterval(wifiBgscan.getShortInterval());
gwtWifiConfig.setBgscanLongInterval(wifiBgscan.getLongInterval());
}
// ping access point?
gwtWifiConfig.setPingAccessPoint(wifiConfig.pingAccessPoint());
// ignore SSID?
gwtWifiConfig.setIgnoreSSID(wifiConfig.ignoreSSID());
// passkey
Password psswd = wifiConfig.getPasskey();
if (psswd != null) {
String password = new String(psswd.getPassword());
gwtWifiConfig.setPassword(password);
}
// channel
int[] channels = wifiConfig.getChannels();
if (channels != null) {
ArrayList<Integer> alChannels = new ArrayList<Integer>();
for (int channel : channels) {
alChannels.add(new Integer(channel));
}
gwtWifiConfig.setChannels(alChannels);
}
// radio mode
GwtWifiRadioMode gwtWifiRadioMode = null;
if (wifiConfig.getRadioMode() != null) {
switch(wifiConfig.getRadioMode()) {
case RADIO_MODE_80211a:
gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeA;
break;
case RADIO_MODE_80211b:
gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeB;
break;
case RADIO_MODE_80211g:
gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeBG;
break;
case RADIO_MODE_80211nHT20:
case RADIO_MODE_80211nHT40above:
case RADIO_MODE_80211nHT40below:
gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeBGN;
break;
default:
break;
}
}
if (gwtWifiRadioMode != null) {
gwtWifiConfig.setRadioMode(gwtWifiRadioMode.name());
}
// set the currently active mode based on the address config
WifiMode activeWirelessMode = ((WifiInterfaceAddressConfig) addressConfig).getMode();
if (activeWirelessMode == WifiMode.MASTER) {
((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name());
gwtNetConfig.setHwRssi("N/A");
} else if (activeWirelessMode == WifiMode.INFRA) {
((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeStation.name());
if (wifiClientMonitorService != null) {
if (wifiConfig.getMode().equals(WifiMode.INFRA)) {
if (gwtNetConfig.getStatus().equals(GwtNetIfStatus.netIPv4StatusDisabled.name())) {
gwtNetConfig.setHwRssi("N/A");
} else {
try {
int rssi = wifiClientMonitorService.getSignalLevel(netIfConfig.getName(), wifiConfig.getSSID());
s_logger.debug("Setting Received Signal Strength to {}", rssi);
gwtNetConfig.setHwRssi(Integer.toString(rssi));
} catch (KuraException e) {
s_logger.warn("Failed", e);
}
}
}
}
} else if (activeWirelessMode == WifiMode.ADHOC) {
((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAdHoc.name());
gwtNetConfig.setHwRssi("N/A");
} else {
((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeDisabled.name());
gwtNetConfig.setHwRssi("N/A");
}
}
if (netConfig instanceof ModemConfig) {
s_logger.debug("Setting up ModemConfig");
ModemConfig modemConfig = (ModemConfig) netConfig;
GwtModemInterfaceConfig gwtModemConfig = (GwtModemInterfaceConfig) gwtNetConfig;
if (modemManagerService != null) {
UsbDevice usbDevice = netIfConfig.getUsbDevice();
String modemServiceId = null;
if (usbDevice != null) {
modemServiceId = netIfConfig.getUsbDevice().getUsbPort();
} else {
Collection<CellularModem> modemServices = modemManagerService.getAllModemServices();
for (CellularModem modemService : modemServices) {
ModemDevice modemDevice = modemService.getModemDevice();
if (modemDevice instanceof SerialModemDevice) {
modemServiceId = modemDevice.getProductName();
break;
}
}
}
if (modemServiceId != null) {
CellularModem cellModemService = modemManagerService.getModemService(modemServiceId);
if (cellModemService != null) {
try {
String imei = cellModemService.getSerialNumber();
s_logger.debug("Setting IMEI/MEID to {}", imei);
gwtModemConfig.setHwSerial(imei);
} catch (KuraException e) {
s_logger.warn("Failed to get IMEI from modem", e);
}
try {
int rssi = cellModemService.getSignalStrength();
s_logger.debug("Setting Received Signal Strength to {}", rssi);
gwtModemConfig.setHwRssi(Integer.toString(rssi));
} catch (KuraException e) {
s_logger.warn("Failed to get Received Signal Strength from modem", e);
}
try {
String sModel = cellModemService.getModel();
((GwtModemInterfaceConfig) gwtNetConfig).setModel(sModel);
} catch (KuraException e) {
s_logger.warn("Failed to get model information from modem", e);
}
try {
boolean gpsSupported = cellModemService.isGpsSupported();
s_logger.debug("Setting GPS supported to {}", gpsSupported);
((GwtModemInterfaceConfig) gwtNetConfig).setGpsSupported(gpsSupported);
} catch (KuraException e) {
s_logger.warn("Failed to get GPS supported from modem", e);
}
}
}
}
// set as DHCP - populate current address
gwtModemConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeDHCP.name());
if (addressConfig.getAddress() != null) {
gwtModemConfig.setIpAddress(addressConfig.getAddress().getHostAddress());
}
if (addressConfig.getNetmask() != null) {
gwtModemConfig.setSubnetMask(addressConfig.getNetmask().getHostAddress());
}
gwtModemConfig.setDialString(modemConfig.getDialString());
AuthType authType = modemConfig.getAuthType();
if (authType == AuthType.AUTO) {
gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthAUTO);
} else if (authType == AuthType.CHAP) {
gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthCHAP);
} else if (authType == AuthType.PAP) {
gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthPAP);
} else {
gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthNONE);
}
gwtModemConfig.setUsername(modemConfig.getUsername());
gwtModemConfig.setPassword(modemConfig.getPassword());
gwtModemConfig.setPppNum(modemConfig.getPppNumber());
gwtModemConfig.setResetTimeout(modemConfig.getResetTimeout());
gwtModemConfig.setPersist(modemConfig.isPersist());
gwtModemConfig.setMaxFail(modemConfig.getMaxFail());
gwtModemConfig.setIdle(modemConfig.getIdle());
gwtModemConfig.setActiveFilter(modemConfig.getActiveFilter());
gwtModemConfig.setLcpEchoInterval(modemConfig.getLcpEchoInterval());
gwtModemConfig.setLcpEchoFailure(modemConfig.getLcpEchoFailure());
gwtModemConfig.setGpsEnabled(modemConfig.isGpsEnabled());
gwtModemConfig.setProfileID(modemConfig.getProfileID());
PdpType pdpType = modemConfig.getPdpType();
if (pdpType == PdpType.IP) {
gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpIP);
} else if (pdpType == PdpType.PPP) {
gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpPPP);
} else if (pdpType == PdpType.IPv6) {
gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpIPv6);
} else {
gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpUnknown);
}
gwtModemConfig.setApn(modemConfig.getApn());
gwtModemConfig.setDataCompression(modemConfig.getDataCompression());
gwtModemConfig.setHeaderCompression(modemConfig.getHeaderCompression());
ModemConnectionStatus connectionStatus = ((ModemInterfaceAddressConfig) addressConfig).getConnectionStatus();
if (connectionStatus == ModemConnectionStatus.DISCONNECTED) {
gwtModemConfig.setHwState(NetInterfaceState.DISCONNECTED.name());
} else if (connectionStatus == ModemConnectionStatus.CONNECTING) {
gwtModemConfig.setHwState(NetInterfaceState.IP_CONFIG.name());
} else if (connectionStatus == ModemConnectionStatus.CONNECTED) {
gwtModemConfig.setHwState(NetInterfaceState.ACTIVATED.name());
} else {
gwtModemConfig.setHwState(NetInterfaceState.UNKNOWN.name());
}
gwtModemConfig.setConnectionType(((ModemInterfaceAddressConfig) addressConfig).getConnectionType().name());
}
if (netConfig instanceof DhcpServerConfigIP4) {
s_logger.debug("Setting up DhcpServerConfigIP4: {} to {}", ((DhcpServerConfigIP4) netConfig).getRangeStart().getHostAddress(), ((DhcpServerConfigIP4) netConfig).getRangeEnd().getHostAddress());
s_logger.debug("Setting up DhcpServerConfigIP4: {}", ((DhcpServerConfigIP4) netConfig).toString());
isDhcpServerEnabled = ((DhcpServerConfigIP4) netConfig).isEnabled();
gwtNetConfig.setRouterDhcpBeginAddress(((DhcpServerConfigIP4) netConfig).getRangeStart().getHostAddress());
gwtNetConfig.setRouterDhcpEndAddress(((DhcpServerConfigIP4) netConfig).getRangeEnd().getHostAddress());
gwtNetConfig.setRouterDhcpSubnetMask(((DhcpServerConfigIP4) netConfig).getSubnetMask().getHostAddress());
gwtNetConfig.setRouterDhcpDefaultLease(((DhcpServerConfigIP4) netConfig).getDefaultLeaseTime());
gwtNetConfig.setRouterDhcpMaxLease(((DhcpServerConfigIP4) netConfig).getMaximumLeaseTime());
gwtNetConfig.setRouterDnsPass(((DhcpServerConfigIP4) netConfig).isPassDns());
}
if (netConfig instanceof FirewallAutoNatConfig) {
s_logger.debug("Setting up FirewallAutoNatConfig");
isNatEnabled = true;
}
// TODO - only dealing with IPv4 right now
}
// set up the DHCP and NAT config
if (isDhcpServerEnabled && isNatEnabled) {
s_logger.debug("setting router mode to DHCP and NAT");
gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterDchpNat.name());
} else if (isDhcpServerEnabled && !isNatEnabled) {
s_logger.debug("setting router mode to DHCP only");
gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterDchp.name());
} else if (!isDhcpServerEnabled && isNatEnabled) {
s_logger.debug("setting router mode to NAT only");
gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterNat.name());
} else {
s_logger.debug("setting router mode to disabled");
gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterOff.name());
}
}
}
}
gwtNetConfigs.add(gwtNetConfig);
}
} catch (Throwable t) {
KuraExceptionHandler.handle(t);
}
s_logger.debug("Returning");
return gwtNetConfigs;
}
Also used :
SerialModemDevice(org.eclipse.kura.net.modem.SerialModemDevice)
FirewallAutoNatConfig(org.eclipse.kura.net.firewall.FirewallAutoNatConfig)
WifiConfig(org.eclipse.kura.net.wifi.WifiConfig)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
ArrayList(java.util.ArrayList)
ModemManagerService(org.eclipse.kura.net.modem.ModemManagerService)
UsbDevice(org.eclipse.kura.usb.UsbDevice)
WifiClientMonitorService(org.eclipse.kura.net.wifi.WifiClientMonitorService)
WifiInterfaceAddressConfig(org.eclipse.kura.net.wifi.WifiInterfaceAddressConfig)
GwtWifiRadioMode(org.eclipse.kura.web.shared.model.GwtWifiRadioMode)
ModemDevice(org.eclipse.kura.net.modem.ModemDevice)
SerialModemDevice(org.eclipse.kura.net.modem.SerialModemDevice)
CellularModem(org.eclipse.kura.net.modem.CellularModem)
KuraException(org.eclipse.kura.KuraException)
GwtKuraException(org.eclipse.kura.web.shared.GwtKuraException)
WifiMode(org.eclipse.kura.net.wifi.WifiMode)
ModemInterfaceAddressConfig(org.eclipse.kura.net.modem.ModemInterfaceAddressConfig)
ModemTechnologyType(org.eclipse.kura.net.modem.ModemTechnologyType)
List(java.util.List)
ArrayList(java.util.ArrayList)
GwtModemInterfaceConfig(org.eclipse.kura.web.shared.model.GwtModemInterfaceConfig)
AuthType(org.eclipse.kura.net.modem.ModemConfig.AuthType)
GwtModemAuthType(org.eclipse.kura.web.shared.model.GwtModemAuthType)
NetInterfaceAddressConfig(org.eclipse.kura.net.NetInterfaceAddressConfig)
ModemInterface(org.eclipse.kura.net.modem.ModemInterface)
IP4Address(org.eclipse.kura.net.IP4Address)
ModemConnectionStatus(org.eclipse.kura.net.modem.ModemConnectionStatus)
ModemConfig(org.eclipse.kura.net.modem.ModemConfig)
NetConfig(org.eclipse.kura.net.NetConfig)
DhcpServerConfigIP4(org.eclipse.kura.net.dhcp.DhcpServerConfigIP4)
NetConfigIP4(org.eclipse.kura.net.NetConfigIP4)
GwtNetInterfaceConfig(org.eclipse.kura.web.shared.model.GwtNetInterfaceConfig)
Password(org.eclipse.kura.configuration.Password)
PdpType(org.eclipse.kura.net.modem.ModemConfig.PdpType)
GwtModemPdpType(org.eclipse.kura.web.shared.model.GwtModemPdpType)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
GwtWifiNetInterfaceConfig(org.eclipse.kura.web.shared.model.GwtWifiNetInterfaceConfig)
WifiBgscan(org.eclipse.kura.net.wifi.WifiBgscan)
NetworkAdminService(org.eclipse.kura.net.NetworkAdminService)
IPAddress(org.eclipse.kura.net.IPAddress)
Example 2 with GwtWifiRadioMode
use of org.eclipse.kura.web.shared.model.GwtWifiRadioMode in project kura by eclipse.
the class TabWirelessUi method initForm.
private void initForm() {
// Wireless Mode
this.labelWireless.setText(MSGS.netWifiWirelessMode());
this.wireless.addItem(MessageUtils.get("netWifiWirelessModeStation"));
this.wireless.addItem(MessageUtils.get("netWifiWirelessModeAccessPoint"));
this.wireless.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.wireless.getSelectedItemText().equals(MessageUtils.get("netWifiWirelessModeStation"))) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipWirelessModeStation()));
} else {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipWirelessModeAccessPoint()));
}
}
});
this.wireless.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.wireless.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
// String accessPointName= WIFI_MODE_ACCESS_POINT_MESSAGE;
// String stationModeName= WIFI_MODE_STATION_MESSAGE;
// if (tcpTab.getStatus().equals(IPV4_STATUS_WAN_MESSAGE) &&
// wireless.getSelectedItemText().equals(accessPointName)) {
// helpWireless.setText(MSGS.netWifiWirelessEnabledForWANError());
// groupWireless.setValidationState(ValidationState.ERROR);
// }else{
TabWirelessUi.this.helpWireless.setText("");
TabWirelessUi.this.groupWireless.setValidationState(ValidationState.NONE);
if (TabWirelessUi.this.wireless.getSelectedItemText().equals(WIFI_MODE_STATION_MESSAGE)) {
// Use Values from station config
TabWirelessUi.this.activeConfig = TabWirelessUi.this.selectedNetIfConfig.getStationWifiConfig();
} else {
// use values from access point config
TabWirelessUi.this.activeConfig = TabWirelessUi.this.selectedNetIfConfig.getAccessPointWifiConfig();
}
TabWirelessUi.this.netTabs.adjustInterfaceTabs();
setPasswordValidation();
update();
}
});
// SSID
this.labelSsid.setText(MSGS.netWifiNetworkName());
this.ssid.setMaxLength(MAX_SSID_LENGTH);
this.ssid.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.ssid.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipNetworkName()));
}
}
});
this.ssid.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.buttonSsid.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
if (!TabWirelessUi.this.ssidInit) {
initSsid();
TabWirelessUi.this.ssidDataProvider.getList().clear();
TabWirelessUi.this.searching.setVisible(true);
TabWirelessUi.this.noSsid.setVisible(false);
TabWirelessUi.this.ssidGrid.setVisible(false);
TabWirelessUi.this.scanFail.setVisible(false);
}
initModal();
loadSsidData();
}
});
// Radio Mode
this.labelRadio.setText(MSGS.netWifiRadioMode());
this.radio.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.radio.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipRadioMode()));
}
}
});
this.radio.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
for (GwtWifiRadioMode mode : GwtWifiRadioMode.values()) {
if (mode != GwtWifiRadioMode.netWifiRadioModeA) {
// We don't support 802.11a yet
this.radio.addItem(MessageUtils.get(mode.name()));
}
}
// Wireless Security
this.labelSecurity.setText(MSGS.netWifiWirelessSecurity());
this.security.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.security.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipSecurity()));
}
}
});
this.security.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
for (GwtWifiSecurity mode : GwtWifiSecurity.values()) {
this.security.addItem(MessageUtils.get(mode.name()));
}
this.security.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
setPasswordValidation();
refreshForm();
checkPassword();
}
});
// Password
this.labelPassword.setText(MSGS.netWifiWirelessPassword());
this.password.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.password.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipPassword()));
}
}
});
this.password.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.buttonPassword.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
EntryClassUi.showWaitModal();
TabWirelessUi.this.buttonPassword.setEnabled(false);
final GwtWifiConfig gwtWifiConfig = getGwtWifiConfig();
TabWirelessUi.this.gwtXSRFService.generateSecurityToken(new AsyncCallback<GwtXSRFToken>() {
@Override
public void onFailure(Throwable ex) {
FailureHandler.handle(ex);
}
@Override
public void onSuccess(GwtXSRFToken token) {
TabWirelessUi.this.gwtNetworkService.verifyWifiCredentials(token, TabWirelessUi.this.selectedNetIfConfig.getName(), gwtWifiConfig, new AsyncCallback<Boolean>() {
@Override
public void onFailure(Throwable caught) {
FailureHandler.handle(caught);
EntryClassUi.hideWaitModal();
TabWirelessUi.this.buttonPassword.setEnabled(true);
showPasswordVerificationStatus(MSGS.netWifiPasswordVerificationFailed());
}
@Override
public void onSuccess(Boolean result) {
if (!result.booleanValue()) {
showPasswordVerificationStatus(MSGS.netWifiPasswordVerificationFailed());
} else {
showPasswordVerificationStatus(MSGS.netWifiPasswordVerificationSuccess());
}
EntryClassUi.hideWaitModal();
TabWirelessUi.this.buttonPassword.setEnabled(true);
}
});
}
});
}
});
this.password.addKeyUpHandler(new KeyUpHandler() {
@Override
public void onKeyUp(KeyUpEvent event) {
if (TabWirelessUi.this.groupVerify.isVisible() && !TabWirelessUi.this.verify.getText().equals(TabWirelessUi.this.password.getText())) {
TabWirelessUi.this.groupVerify.setValidationState(ValidationState.ERROR);
} else {
TabWirelessUi.this.groupVerify.setValidationState(ValidationState.NONE);
}
}
});
this.password.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
refreshForm();
checkPassword();
}
});
// Verify Password
this.labelVerify.setText(MSGS.netWifiWirelessVerifyPassword());
this.verify.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.verify.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipPassword()));
}
}
});
this.verify.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.verify.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
if (TabWirelessUi.this.password != null && !TabWirelessUi.this.verify.getText().equals(TabWirelessUi.this.password.getText())) {
TabWirelessUi.this.helpVerify.setText(MSGS.netWifiWirelessPasswordDoesNotMatch());
TabWirelessUi.this.groupVerify.setValidationState(ValidationState.ERROR);
} else {
TabWirelessUi.this.helpVerify.setText("");
TabWirelessUi.this.groupVerify.setValidationState(ValidationState.NONE);
}
}
});
// Pairwise ciphers
this.labelPairwise.setText(MSGS.netWifiWirelessPairwiseCiphers());
this.pairwise.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.pairwise.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipPairwiseCiphers()));
}
}
});
this.pairwise.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
this.pairwise.addItem(MessageUtils.get(ciphers.name()));
}
this.pairwise.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
refreshForm();
}
});
// Groupwise Ciphers
this.labelGroup.setText(MSGS.netWifiWirelessGroupCiphers());
this.group.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.group.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiWirelessGroupCiphers()));
}
}
});
this.group.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
this.group.addItem(MessageUtils.get(ciphers.name()));
}
this.group.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
refreshForm();
}
});
// Bgscan module
this.labelBgscan.setText(MSGS.netWifiWirelessBgscanModule());
this.bgscan.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.bgscan.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipBgScan()));
}
}
});
this.bgscan.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
for (GwtWifiBgscanModule module : GwtWifiBgscanModule.values()) {
this.bgscan.addItem(MessageUtils.get(module.name()));
}
this.bgscan.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
refreshForm();
}
});
// BgScan RSSI threshold
this.labelRssi.setText(MSGS.netWifiWirelessBgscanSignalStrengthThreshold());
// TODO: DW - RSSI slider
/*
* rssi.addSlideStartHandler(new SlideStartHandler<Double>() {
*
* @Override
* public void onSlideStart(SlideStartEvent<Double> event) {
* if (rssi.isEnabled()) {
* helpText.clear();
* helpText.add(new Span(MSGS.netWifiToolTipBgScanStrength()));
* }
* }
* });
* rssi.addSlideStopHandler(new SlideStopHandler<Double>() {
*
* @Override
* public void onSlideStop(SlideStopEvent<Double> event) {
* resetHelp();
* }
* });
*/
// Bgscan short Interval
this.labelShortI.setText(MSGS.netWifiWirelessBgscanShortInterval());
this.shortI.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.shortI.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipBgScanShortInterval()));
}
}
});
this.shortI.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.shortI.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
if (TabWirelessUi.this.shortI.getText().trim().contains(".") || TabWirelessUi.this.shortI.getText().trim().contains("-") || !TabWirelessUi.this.shortI.getText().trim().matches("[0-9]+")) {
TabWirelessUi.this.groupShortI.setValidationState(ValidationState.ERROR);
} else {
TabWirelessUi.this.groupShortI.setValidationState(ValidationState.NONE);
}
}
});
// Bgscan long interval
this.labelLongI.setText(MSGS.netWifiWirelessBgscanLongInterval());
this.longI.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.longI.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipBgScanLongInterval()));
}
}
});
this.longI.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.longI.addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
if (TabWirelessUi.this.longI.getText().trim().contains(".") || TabWirelessUi.this.longI.getText().trim().contains("-") || !TabWirelessUi.this.longI.getText().trim().matches("[0-9]+")) {
TabWirelessUi.this.groupLongI.setValidationState(ValidationState.ERROR);
} else {
TabWirelessUi.this.groupLongI.setValidationState(ValidationState.NONE);
}
}
});
// Ping Access Point ----
this.labelPing.setText(MSGS.netWifiWirelessPingAccessPoint());
this.radio1.setText(MSGS.trueLabel());
this.radio1.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.radio1.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipPingAccessPoint()));
}
}
});
this.radio1.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.radio2.setText(MSGS.falseLabel());
this.radio2.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.radio2.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipPingAccessPoint()));
}
}
});
this.radio2.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
// Ignore Broadcast SSID
this.labelIgnore.setText(MSGS.netWifiWirelessIgnoreSSID());
this.radio3.setText(MSGS.trueLabel());
this.radio3.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.radio3.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipIgnoreSSID()));
}
}
});
this.radio3.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
this.radio4.setText(MSGS.falseLabel());
this.radio4.addMouseOverHandler(new MouseOverHandler() {
@Override
public void onMouseOver(MouseOverEvent event) {
if (TabWirelessUi.this.radio4.isEnabled()) {
TabWirelessUi.this.helpText.clear();
TabWirelessUi.this.helpText.add(new Span(MSGS.netWifiToolTipIgnoreSSID()));
}
}
});
this.radio4.addMouseOutHandler(new MouseOutHandler() {
@Override
public void onMouseOut(MouseOutEvent event) {
resetHelp();
}
});
// Channel Grid
initGrid();
this.helpTitle.setText(MSGS.netHelpTitle());
}
Also used :
GwtWifiCiphers(org.eclipse.kura.web.shared.model.GwtWifiCiphers)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
KeyUpEvent(com.google.gwt.event.dom.client.KeyUpEvent)
ClickEvent(com.google.gwt.event.dom.client.ClickEvent)
AsyncCallback(com.google.gwt.user.client.rpc.AsyncCallback)
GwtWifiRadioMode(org.eclipse.kura.web.shared.model.GwtWifiRadioMode)
GwtWifiBgscanModule(org.eclipse.kura.web.shared.model.GwtWifiBgscanModule)
KeyUpHandler(com.google.gwt.event.dom.client.KeyUpHandler)
Span(org.gwtbootstrap3.client.ui.html.Span)
GwtXSRFToken(org.eclipse.kura.web.shared.model.GwtXSRFToken)
MouseOutEvent(com.google.gwt.event.dom.client.MouseOutEvent)
MouseOutHandler(com.google.gwt.event.dom.client.MouseOutHandler)
ClickHandler(com.google.gwt.event.dom.client.ClickHandler)
SelectionChangeEvent(com.google.gwt.view.client.SelectionChangeEvent)
ChangeEvent(com.google.gwt.event.dom.client.ChangeEvent)
ChangeHandler(com.google.gwt.event.dom.client.ChangeHandler)
MouseOverEvent(com.google.gwt.event.dom.client.MouseOverEvent)
MouseOverHandler(com.google.gwt.event.dom.client.MouseOverHandler)
GwtWifiSecurity(org.eclipse.kura.web.shared.model.GwtWifiSecurity)
Example 3 with GwtWifiRadioMode
use of org.eclipse.kura.web.shared.model.GwtWifiRadioMode in project kura by eclipse.
the class WirelessConfigTab method onRender.
protected void onRender(Element parent, int index) {
super.onRender(parent, index);
setLayout(new FitLayout());
setId("network-wireless");
FormData formData = new FormData();
formData.setWidth(250);
m_formPanel = new FormPanel();
m_formPanel.setFrame(false);
m_formPanel.setBodyBorder(false);
m_formPanel.setHeaderVisible(false);
m_formPanel.setLayout(new FlowLayout());
m_formPanel.setStyleAttribute("min-width", "775px");
m_formPanel.setStyleAttribute("padding-left", "30px");
FieldSet fieldSet = new FieldSet();
FormLayout layoutAccount = new FormLayout();
layoutAccount.setLabelWidth(Constants.LABEL_WIDTH_FORM);
fieldSet.setLayout(layoutAccount);
fieldSet.setBorders(false);
//
// Tool Tip Box
//
toolTipField.setText(defaultToolTip);
fieldSet.add(toolTipField);
//
// Wireless Mode
//
m_wirelessModeListStore = new ListStore<GwtWifiWirelessModeModel>();
/*
m_wirelessModeListStore.add(new GwtWifiWirelessModeModel(GwtWifiWirelessMode.netWifiWirelessModeDisabled,
MessageUtils.get("netWifiWirelessModeDisabled"),
MSGS.netWifiToolTipWirelessModeDisabled()));
*/
m_wirelessModeListStore.add(new GwtWifiWirelessModeModel(GwtWifiWirelessMode.netWifiWirelessModeStation, MessageUtils.get("netWifiWirelessModeStation"), MSGS.netWifiToolTipWirelessModeStation()));
m_wirelessModeListStore.add(new GwtWifiWirelessModeModel(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint, MessageUtils.get("netWifiWirelessModeAccessPoint"), MSGS.netWifiToolTipWirelessModeAccessPoint()));
/*
m_wirelessModeListStore.add(new GwtWifiWirelessModeModel(GwtWifiWirelessMode.netWifiWirelessModeAdHoc,
MessageUtils.get("netWifiWirelessModeAdHoc"),
MSGS.netWifiToolTipWirelessModeAdhoc()));
*/
m_modeCombo = new ComboBox<GwtWifiWirelessModeModel>();
m_modeCombo.setName("comboMode");
m_modeCombo.setDisplayField(GwtWifiWirelessModeModel.NAME);
m_modeCombo.setFieldLabel(MSGS.netWifiWirelessMode());
m_modeCombo.setEditable(false);
m_modeCombo.setTypeAhead(true);
m_modeCombo.setTriggerAction(TriggerAction.ALL);
m_modeCombo.addStyleName("kura-combobox");
m_modeCombo.setStore(m_wirelessModeListStore);
m_modeCombo.setTemplate(getTemplate());
m_modeCombo.setValue(m_wirelessModeListStore.findModel(GwtWifiWirelessModeModel.MODE, GwtWifiWirelessMode.netWifiWirelessModeStation.name()));
m_modeCombo.setValidator(new Validator() {
public String validate(Field<?> field, String value) {
if (m_tcpIpConfigTab.getStatus().equals(GwtNetIfStatus.netIPv4StatusEnabledWAN) && value.equals(MessageUtils.get(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name()))) {
return MSGS.netWifiWirelessEnabledForWANError();
}
return null;
}
});
m_modeCombo.addSelectionChangedListener(new SelectionChangedListener<GwtWifiWirelessModeModel>() {
@Override
public void selectionChanged(SelectionChangedEvent<GwtWifiWirelessModeModel> se) {
// Station mode selected
if (GwtWifiWirelessMode.netWifiWirelessModeStation.equals(se.getSelectedItem().getMode())) {
// Use values from station config
m_activeWifiConfig = m_selectNetIfConfig.getStationWifiConfig();
} else {
// Use values from access point config
m_activeWifiConfig = m_selectNetIfConfig.getAccessPointWifiConfig();
}
setPasswordValidation();
setValues(false);
refreshForm();
}
});
m_modeCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipWirelessMode()));
m_modeCombo.addPlugin(m_dirtyPlugin);
Button ssidPickerButton = new Button("", AbstractImagePrototype.create(Resources.INSTANCE.magnifier16()), new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
m_wifiNetworksWindow = createWifiNetworksWindow();
m_wifiNetworksWindow.show();
m_wifiHotspotLoader.load();
}
});
//
// SSID
//
m_ssidField = new TextFieldWithButton<String>(ssidPickerButton, 10);
m_ssidField.setAllowBlank(true);
m_ssidField.setId("ssid-input");
m_ssidField.setName("ssid");
m_ssidField.setFieldLabel(MSGS.netWifiNetworkName());
m_ssidField.setEnabled(true, false);
m_ssidField.addPlugin(m_dirtyPlugin);
m_ssidField.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipNetworkName()));
m_ssidField.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
m_ssidField.setMaxLength(MAX_SSID_LENGTH);
//
// Radio Mode
//
m_radioModeCombo = new SimpleComboBox<String>();
m_radioModeCombo.setName("radioMode");
m_radioModeCombo.setFieldLabel(MSGS.netWifiRadioMode());
m_radioModeCombo.setEditable(false);
m_radioModeCombo.setTypeAhead(true);
m_radioModeCombo.setTriggerAction(TriggerAction.ALL);
for (GwtWifiRadioMode mode : GwtWifiRadioMode.values()) {
if (mode != GwtWifiRadioMode.netWifiRadioModeA) {
// we don't support 802.11a yet
m_radioModeCombo.add(MessageUtils.get(mode.name()));
}
}
m_radioModeCombo.setSimpleValue(MessageUtils.get(GwtWifiRadioMode.netWifiRadioModeBGN.name()));
m_radioModeCombo.addSelectionChangedListener(new SelectionChangedListener<SimpleComboValue<String>>() {
@Override
public void selectionChanged(SelectionChangedEvent<SimpleComboValue<String>> se) {
refreshForm();
}
});
m_radioModeCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipRadioMode()));
m_radioModeCombo.addStyleName("kura-combobox");
m_radioModeCombo.addPlugin(m_dirtyPlugin);
//
// Wireless Security
//
m_securityCombo = new SimpleComboBox<String>();
m_securityCombo.setName("security");
m_securityCombo.setFieldLabel(MSGS.netWifiWirelessSecurity());
m_securityCombo.setEditable(false);
m_securityCombo.setTypeAhead(true);
m_securityCombo.setTriggerAction(TriggerAction.ALL);
m_securityCombo.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
for (GwtWifiSecurity mode : GwtWifiSecurity.values()) {
m_securityCombo.add(MessageUtils.get(mode.name()));
}
m_securityCombo.setSimpleValue(MessageUtils.get(GwtWifiSecurity.netWifiSecurityWPA2.name()));
m_securityCombo.addSelectionChangedListener(new SelectionChangedListener<SimpleComboValue<String>>() {
@Override
public void selectionChanged(SelectionChangedEvent<SimpleComboValue<String>> se) {
setPasswordValidation();
refreshForm();
}
});
m_securityCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipSecurity()));
m_securityCombo.addStyleName("kura-combobox");
m_securityCombo.addPlugin(m_dirtyPlugin);
Button passwordButton = new Button("", AbstractImagePrototype.create(Resources.INSTANCE.connect16()), new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
m_passwordField.setIcon(AbstractImagePrototype.create(Resources.INSTANCE.hourglass16()));
m_passwordField.setEnabled(true, false);
gwtXSRFService.generateSecurityToken(new AsyncCallback<GwtXSRFToken>() {
@Override
public void onFailure(Throwable ex) {
FailureHandler.handle(ex);
}
@Override
public void onSuccess(GwtXSRFToken token) {
GwtWifiConfig gwtWifiConfig = getGwtWifiConfig();
gwtNetworkService.verifyWifiCredentials(token, m_selectNetIfConfig.getName(), gwtWifiConfig, new AsyncCallback<Boolean>() {
public void onSuccess(Boolean result) {
Log.warn("verifyWifiCredentials() :: result=" + result);
if (!result.booleanValue()) {
m_passwordField.setValue("");
}
m_passwordField.setIcon(AbstractImagePrototype.create(Resources.INSTANCE.connect16()));
m_passwordField.setEnabled(true, true);
}
public void onFailure(Throwable caught) {
Log.warn("verifyWifiCredentials() :: caught: " + caught.toString());
m_passwordField.setIcon(AbstractImagePrototype.create(Resources.INSTANCE.connect16()));
m_passwordField.setEnabled(true, true);
}
});
}
});
}
});
//
// Password
//
m_passwordField = new TextFieldWithButton<String>(passwordButton, 10);
m_passwordField.setId("wifi-password");
m_passwordField.setName("password");
m_passwordField.setFieldLabel(MSGS.netWifiWirelessPassword());
m_passwordField.setPassword(true);
m_passwordField.setRegex(PASSWORD_REGEX_ANY);
m_passwordField.getMessages().setRegexText(MSGS.netWifiWirelessInvalidWPAPassword());
m_passwordField.addPlugin(m_dirtyPlugin);
m_passwordField.setAutoValidate(true);
m_passwordField.setAllowBlank(false);
m_passwordField.addKeyListener(new KeyListener() {
@Override
public void componentKeyUp(ComponentEvent event) {
super.componentKeyUp(event);
m_verifyPasswordField.validate();
}
});
m_passwordField.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipPassword()));
m_passwordField.addListener(Events.OnChange, new Listener<BaseEvent>() {
public void handleEvent(BaseEvent be) {
setPasswordValidation();
refreshForm();
}
});
//
// Verify Password
//
m_verifyPasswordField = new TextField<String>();
m_verifyPasswordField.setName("verifyPassword");
m_verifyPasswordField.setFieldLabel(MSGS.netWifiWirelessVerifyPassword());
m_verifyPasswordField.setPassword(true);
m_verifyPasswordField.addPlugin(m_dirtyPlugin);
// TODO:
m_verifyPasswordField.getMessages().setInvalidText("Invalid text 123");
m_verifyPasswordField.setAutoValidate(true);
m_verifyPasswordField.setAllowBlank(false);
m_verifyPasswordField.setValidator(new Validator() {
public String validate(Field<?> field, String value) {
if (m_modeCombo != null && GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.equals(m_modeCombo.getValue().getMode())) {
// Check that the verify password field matches
if (m_passwordField == null || !value.equals(m_passwordField.getValue())) {
return MSGS.netWifiWirelessPasswordDoesNotMatch();
}
}
return null;
}
});
m_verifyPasswordField.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipVerifyPassword()));
m_verifyPasswordField.addStyleName("kura-textfield");
// pairwise ciphers
m_pairwiseCiphersCombo = new SimpleComboBox<String>();
m_pairwiseCiphersCombo.setName("pairwiseCiphers");
m_pairwiseCiphersCombo.setFieldLabel(MSGS.netWifiWirelessPairwiseCiphers());
m_pairwiseCiphersCombo.setEditable(false);
m_pairwiseCiphersCombo.setTypeAhead(true);
m_pairwiseCiphersCombo.setTriggerAction(TriggerAction.ALL);
// m_pairwiseCiphersCombo.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
m_pairwiseCiphersCombo.add(MessageUtils.get(ciphers.name()));
}
m_pairwiseCiphersCombo.setSimpleValue(MessageUtils.get(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name()));
m_pairwiseCiphersCombo.addSelectionChangedListener(new SelectionChangedListener<SimpleComboValue<String>>() {
@Override
public void selectionChanged(SelectionChangedEvent<SimpleComboValue<String>> se) {
refreshForm();
}
});
m_pairwiseCiphersCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipPairwiseCiphers()));
m_pairwiseCiphersCombo.addStyleName("kura-combobox");
m_pairwiseCiphersCombo.addPlugin(m_dirtyPlugin);
// group ciphers
m_groupCiphersCombo = new SimpleComboBox<String>();
m_groupCiphersCombo.setName("groupCiphers");
m_groupCiphersCombo.setFieldLabel(MSGS.netWifiWirelessGroupCiphers());
m_groupCiphersCombo.setEditable(false);
m_groupCiphersCombo.setTypeAhead(true);
m_groupCiphersCombo.setTriggerAction(TriggerAction.ALL);
// m_groupCiphersCombo.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
m_groupCiphersCombo.add(MessageUtils.get(ciphers.name()));
}
m_groupCiphersCombo.setSimpleValue(MessageUtils.get(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name()));
m_groupCiphersCombo.addSelectionChangedListener(new SelectionChangedListener<SimpleComboValue<String>>() {
@Override
public void selectionChanged(SelectionChangedEvent<SimpleComboValue<String>> se) {
refreshForm();
}
});
m_groupCiphersCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipGroupCiphers()));
m_groupCiphersCombo.addStyleName("kura-combobox");
m_groupCiphersCombo.addPlugin(m_dirtyPlugin);
// bgscan module
m_bgscanModuleCombo = new SimpleComboBox<String>();
m_bgscanModuleCombo.setName("groupCiphers");
m_bgscanModuleCombo.setFieldLabel(MSGS.netWifiWirelessBgscanModule());
m_bgscanModuleCombo.setEditable(false);
m_bgscanModuleCombo.setTypeAhead(true);
m_bgscanModuleCombo.setTriggerAction(TriggerAction.ALL);
m_bgscanModuleCombo.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
for (GwtWifiBgscanModule module : GwtWifiBgscanModule.values()) {
m_bgscanModuleCombo.add(MessageUtils.get(module.name()));
}
m_bgscanModuleCombo.setSimpleValue(MessageUtils.get(GwtWifiBgscanModule.netWifiBgscanMode_NONE.name()));
m_bgscanModuleCombo.addSelectionChangedListener(new SelectionChangedListener<SimpleComboValue<String>>() {
@Override
public void selectionChanged(SelectionChangedEvent<SimpleComboValue<String>> se) {
refreshForm();
}
});
m_bgscanModuleCombo.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipBgScan()));
m_bgscanModuleCombo.addStyleName("kura-combobox");
m_bgscanModuleCombo.addPlugin(m_dirtyPlugin);
// bgscan RSSI Threshold
m_bgscanRssiThresholdSlider = new Slider();
m_bgscanRssiThresholdSlider.setWidth(200);
m_bgscanRssiThresholdSlider.setIncrement(1);
m_bgscanRssiThresholdSlider.setMinValue(-90);
m_bgscanRssiThresholdSlider.setMaxValue(-20);
m_bgscanRssiThresholdSlider.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipBgScanStrength()));
m_bgscanRssiThresholdSlider.setClickToChange(false);
m_bgscanRssiThresholdSliderField = new SliderField(m_bgscanRssiThresholdSlider);
m_bgscanRssiThresholdSliderField.setFieldLabel(MSGS.netWifiWirelessBgscanSignalStrengthThreshold());
// bgscan short interval
m_bgscanShortIntervalField = new NumberField();
m_bgscanShortIntervalField.setPropertyEditorType(Integer.class);
m_bgscanShortIntervalField.setAllowDecimals(false);
m_bgscanShortIntervalField.setAllowNegative(false);
m_bgscanShortIntervalField.setAllowBlank(true);
m_bgscanShortIntervalField.setName("bgscanShortInterval");
m_bgscanShortIntervalField.setFieldLabel(MSGS.netWifiWirelessBgscanShortInterval());
m_bgscanShortIntervalField.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipBgScanShortInterval()));
m_bgscanShortIntervalField.addPlugin(m_dirtyPlugin);
// m_bgscanShortInterval.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
// bgscan long interval
m_bgscanLongIntervalField = new NumberField();
m_bgscanLongIntervalField.setPropertyEditorType(Integer.class);
m_bgscanLongIntervalField.setAllowDecimals(false);
m_bgscanLongIntervalField.setAllowNegative(false);
m_bgscanLongIntervalField.setAllowBlank(true);
m_bgscanLongIntervalField.setName("bgscanLongInterval");
m_bgscanLongIntervalField.setFieldLabel(MSGS.netWifiWirelessBgscanLongInterval());
m_bgscanLongIntervalField.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipBgScanLongInterval()));
m_bgscanLongIntervalField.addPlugin(m_dirtyPlugin);
m_pingAccessPointRadioTrue = new Radio();
m_pingAccessPointRadioTrue.setBoxLabel(MSGS.trueLabel());
m_pingAccessPointRadioTrue.setItemId("true");
m_pingAccessPointRadioTrue.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipPingAccessPoint()));
m_pingAccessPointRadioFalse = new Radio();
m_pingAccessPointRadioFalse.setBoxLabel(MSGS.falseLabel());
m_pingAccessPointRadioFalse.setItemId("false");
m_pingAccessPointRadioFalse.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipPingAccessPoint()));
m_pingAccessPointRadioGroup = new RadioGroup();
m_pingAccessPointRadioGroup.setName("pingAccessPoint");
m_pingAccessPointRadioGroup.setFieldLabel(MSGS.netWifiWirelessPingAccessPoint());
m_pingAccessPointRadioGroup.add(m_pingAccessPointRadioTrue);
m_pingAccessPointRadioGroup.add(m_pingAccessPointRadioFalse);
m_pingAccessPointRadioGroup.addPlugin(m_dirtyPlugin);
m_pingAccessPointRadioGroup.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
m_ignoreSsidRadioTrue = new Radio();
m_ignoreSsidRadioTrue.setBoxLabel(MSGS.trueLabel());
m_ignoreSsidRadioTrue.setItemId("true");
m_ignoreSsidRadioTrue.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipIgnoreSSID()));
m_ignoreSsidRadioFalse = new Radio();
m_ignoreSsidRadioFalse.setBoxLabel(MSGS.falseLabel());
m_ignoreSsidRadioFalse.setItemId("false");
m_ignoreSsidRadioFalse.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipIgnoreSSID()));
m_ignoreSsidRadioGroup = new RadioGroup();
m_ignoreSsidRadioGroup.setName("ignoreSSID");
m_ignoreSsidRadioGroup.setFieldLabel(MSGS.netWifiWirelessIgnoreSSID());
m_ignoreSsidRadioGroup.add(m_ignoreSsidRadioTrue);
m_ignoreSsidRadioGroup.add(m_ignoreSsidRadioFalse);
m_ignoreSsidRadioGroup.addPlugin(m_dirtyPlugin);
m_ignoreSsidRadioGroup.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
//
// Channel
//
GroupingStore<GwtWifiChannelModel> grtoupingStore = new GroupingStore<GwtWifiChannelModel>();
grtoupingStore.setMonitorChanges(true);
grtoupingStore.add(GwtWifiChannelModel.getChannels());
grtoupingStore.groupBy("band");
ColumnConfig channel = new ColumnConfig("name", "All Available Channels", 20);
ColumnConfig frequency = new ColumnConfig("frequency", "Frequency (MHz)", 10);
ColumnConfig band = new ColumnConfig("band", "Spectrum Band", 20);
List<ColumnConfig> channelColumnConfig = new ArrayList<ColumnConfig>();
channelColumnConfig.add(m_checkboxChannelSelectionModel.getColumn());
channelColumnConfig.add(channel);
channelColumnConfig.add(frequency);
channelColumnConfig.add(band);
final ColumnModel columnModel = new ColumnModel(channelColumnConfig);
m_channelGroupingView = new GroupingView() {
@Override
protected void onMouseDown(GridEvent<ModelData> ge) {
El hd = ge.getTarget(".x-grid-group-hd", 10);
El target = ge.getTargetEl();
if (hd != null && target.hasStyleName(m_uncheckedStyle) || target.hasStyleName(m_checkedStyle)) {
boolean checked = !ge.getTargetEl().hasStyleName(m_uncheckedStyle);
checked = !checked;
if (checked) {
ge.getTargetEl().replaceStyleName(m_uncheckedStyle, m_checkedStyle);
} else {
ge.getTargetEl().replaceStyleName(m_checkedStyle, m_uncheckedStyle);
}
Element group = (Element) findGroup(ge.getTarget());
if (group != null) {
NodeList<Element> rows = El.fly(group).select(".x-grid3-row");
List<ModelData> temp = new ArrayList<ModelData>();
for (int i = 0; i < rows.getLength(); i++) {
Element r = rows.getItem(i);
int idx = findRowIndex(r);
ModelData m = grid.getStore().getAt(idx);
temp.add(m);
}
if (checked) {
grid.getSelectionModel().select(temp, true);
} else {
grid.getSelectionModel().deselect(temp);
}
}
return;
}
super.onMouseDown(ge);
}
};
m_channelGroupingView.setShowGroupedColumn(false);
m_channelGroupingView.setForceFit(true);
m_channelGroupingView.setShowDirtyCells(true);
m_channelGroupingView.setGroupRenderer(new GridGroupRenderer() {
public String render(GroupColumnData data) {
String f = columnModel.getColumnById(data.field).getHeader();
String l = data.models.size() == 1 ? "Item" : "Items";
return "<div class='x-grid3-group-checker'><div class='" + m_uncheckedStyle + "'> </div></div> " + f + ": " + data.group + " (" + data.models.size() + " " + l + ")";
}
});
final Grid<GwtWifiChannelModel> channelGrid = new Grid<GwtWifiChannelModel>(grtoupingStore, columnModel);
channelGrid.setView(m_channelGroupingView);
channelGrid.setBorders(true);
channelGrid.addPlugin(m_checkboxChannelSelectionModel);
channelGrid.setSelectionModel(m_checkboxChannelSelectionModel);
channelGrid.addPlugin(m_dirtyPlugin);
m_channelPanel = new ContentPanel();
m_channelPanel.setHeading("Select Channel(s)");
m_channelPanel.setCollapsible(true);
m_channelPanel.setFrame(true);
m_channelPanel.setSize(430, 200);
m_channelPanel.setLayout(new FitLayout());
m_channelPanel.setStyleAttribute("margin-top", Constants.LABEL_MARGIN_TOP_SEPARATOR);
m_channelPanel.add(channelGrid);
m_channelPanel.addListener(Events.OnMouseOver, new MouseOverListener(MSGS.netWifiToolTipChannels()));
m_checkboxChannelSelectionModel.addSelectionChangedListener(new SelectionChangedListener<GwtWifiChannelModel>() {
@Override
public void selectionChanged(SelectionChangedEvent<GwtWifiChannelModel> se) {
updateSelectedChannels(se.getSelection());
}
});
// Adjust the number of channels shown based on defined property
gwtXSRFService.generateSecurityToken(new AsyncCallback<GwtXSRFToken>() {
@Override
public void onFailure(Throwable ex) {
FailureHandler.handle(ex);
}
@Override
public void onSuccess(GwtXSRFToken token) {
gwtDeviceService.findDeviceConfiguration(token, new AsyncCallback<ListLoadResult<GwtGroupedNVPair>>() {
public void onSuccess(ListLoadResult<GwtGroupedNVPair> results) {
if (results != null) {
List<GwtGroupedNVPair> pairs = results.getData();
if (pairs != null) {
for (GwtGroupedNVPair pair : pairs) {
String name = pair.getName();
if (name != null && name.equals("devLastWifiChannel")) {
int topChannel = Integer.parseInt(pair.getValue());
// Remove channels 12 and 13
if (topChannel < MAX_WIFI_CHANNEL) {
channelGrid.getStore().remove(MAX_WIFI_CHANNEL - 1);
channelGrid.getStore().remove(MAX_WIFI_CHANNEL - 2);
}
}
}
}
}
}
public void onFailure(Throwable caught) {
FailureHandler.handle(caught);
}
});
}
});
fieldSet.add(m_modeCombo, formData);
fieldSet.add(m_ssidField, formData);
fieldSet.add(m_radioModeCombo, formData);
fieldSet.add(m_securityCombo, formData);
fieldSet.add(m_passwordField, formData);
fieldSet.add(m_verifyPasswordField, formData);
fieldSet.add(m_pairwiseCiphersCombo, formData);
fieldSet.add(m_groupCiphersCombo, formData);
fieldSet.add(m_bgscanModuleCombo, formData);
fieldSet.add(m_bgscanRssiThresholdSliderField, formData);
fieldSet.add(m_bgscanShortIntervalField, formData);
fieldSet.add(m_bgscanLongIntervalField, formData);
fieldSet.add(m_pingAccessPointRadioGroup, formData);
fieldSet.add(m_ignoreSsidRadioGroup, formData);
fieldSet.add(m_channelPanel, formData);
if ((m_securityCombo.getSimpleValue().equals(MessageUtils.get(GwtWifiSecurity.netWifiSecurityWPA2.name()))) || (m_securityCombo.getSimpleValue().equals(MessageUtils.get(GwtWifiSecurity.netWifiSecurityWPA.name()))) || (m_securityCombo.getSimpleValue().equals(MessageUtils.get(GwtWifiSecurity.netWifiSecurityWPA_WPA2.name())))) {
if (GwtWifiWirelessMode.netWifiWirelessModeStation.equals(m_modeCombo.getValue().getMode())) {
m_pairwiseCiphersCombo.setEnabled(true);
m_groupCiphersCombo.setEnabled(true);
} else {
// m_pairwiseCiphersCombo.setEnabled(false); // enable it for AP mode as well
m_pairwiseCiphersCombo.setEnabled(true);
m_groupCiphersCombo.setEnabled(false);
}
} else {
m_pairwiseCiphersCombo.setEnabled(false);
m_groupCiphersCombo.setEnabled(false);
}
m_formPanel.add(fieldSet);
m_formPanel.setScrollMode(Scroll.AUTO);
add(m_formPanel);
setScrollMode(Scroll.AUTOX);
m_initialized = true;
}
Also used :
RadioGroup(com.extjs.gxt.ui.client.widget.form.RadioGroup)
ColumnConfig(com.extjs.gxt.ui.client.widget.grid.ColumnConfig)
SimpleComboValue(com.extjs.gxt.ui.client.widget.form.SimpleComboValue)
AsyncCallback(com.google.gwt.user.client.rpc.AsyncCallback)
ArrayList(java.util.ArrayList)
GwtWifiRadioMode(org.eclipse.kura.web.shared.model.GwtWifiRadioMode)
GwtXSRFToken(org.eclipse.kura.web.shared.model.GwtXSRFToken)
GroupingStore(com.extjs.gxt.ui.client.store.GroupingStore)
Button(com.extjs.gxt.ui.client.widget.button.Button)
TextFieldWithButton(org.eclipse.kura.web.client.util.TextFieldWithButton)
NodeList(com.google.gwt.dom.client.NodeList)
List(java.util.List)
ArrayList(java.util.ArrayList)
FormData(com.extjs.gxt.ui.client.widget.layout.FormData)
NodeList(com.google.gwt.dom.client.NodeList)
GroupColumnData(com.extjs.gxt.ui.client.widget.grid.GroupColumnData)
ContentPanel(com.extjs.gxt.ui.client.widget.ContentPanel)
GwtWifiChannelModel(org.eclipse.kura.web.shared.model.GwtWifiChannelModel)
GridGroupRenderer(com.extjs.gxt.ui.client.widget.grid.GridGroupRenderer)
GwtWifiSecurity(org.eclipse.kura.web.shared.model.GwtWifiSecurity)
ComponentEvent(com.extjs.gxt.ui.client.event.ComponentEvent)
ModelData(com.extjs.gxt.ui.client.data.ModelData)
FlowLayout(com.extjs.gxt.ui.client.widget.layout.FlowLayout)
GwtWifiCiphers(org.eclipse.kura.web.shared.model.GwtWifiCiphers)
Slider(com.extjs.gxt.ui.client.widget.Slider)
El(com.extjs.gxt.ui.client.core.El)
Element(com.google.gwt.user.client.Element)
Grid(com.extjs.gxt.ui.client.widget.grid.Grid)
GwtGroupedNVPair(org.eclipse.kura.web.shared.model.GwtGroupedNVPair)
FieldSet(com.extjs.gxt.ui.client.widget.form.FieldSet)
GwtWifiWirelessModeModel(org.eclipse.kura.web.shared.model.GwtWifiWirelessModeModel)
GroupingView(com.extjs.gxt.ui.client.widget.grid.GroupingView)
FitLayout(com.extjs.gxt.ui.client.widget.layout.FitLayout)
FormLayout(com.extjs.gxt.ui.client.widget.layout.FormLayout)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
BaseEvent(com.extjs.gxt.ui.client.event.BaseEvent)
Radio(com.extjs.gxt.ui.client.widget.form.Radio)
GwtWifiBgscanModule(org.eclipse.kura.web.shared.model.GwtWifiBgscanModule)
SliderField(com.extjs.gxt.ui.client.widget.form.SliderField)
NumberField(com.extjs.gxt.ui.client.widget.form.NumberField)
ListLoadResult(com.extjs.gxt.ui.client.data.ListLoadResult)
FormPanel(com.extjs.gxt.ui.client.widget.form.FormPanel)
ButtonEvent(com.extjs.gxt.ui.client.event.ButtonEvent)
KeyListener(com.extjs.gxt.ui.client.event.KeyListener)
ColumnModel(com.extjs.gxt.ui.client.widget.grid.ColumnModel)
Validator(com.extjs.gxt.ui.client.widget.form.Validator)
Example 4 with GwtWifiRadioMode
use of org.eclipse.kura.web.shared.model.GwtWifiRadioMode in project kura by eclipse.
the class TabWirelessUi method getGwtWifiConfig.
private GwtWifiConfig getGwtWifiConfig() {
GwtWifiConfig gwtWifiConfig = new GwtWifiConfig();
// mode
GwtWifiWirelessMode wifiMode;
if (this.wireless.getSelectedItemText().equals(MessageUtils.get(WIFI_MODE_STATION))) {
wifiMode = GwtWifiWirelessMode.netWifiWirelessModeStation;
} else {
wifiMode = GwtWifiWirelessMode.netWifiWirelessModeAccessPoint;
}
gwtWifiConfig.setWirelessMode(wifiMode.name());
// ssid
gwtWifiConfig.setWirelessSsid(GwtSafeHtmlUtils.htmlUnescape(this.ssid.getText().trim()));
// driver
String driver = "";
if (GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.equals(wifiMode)) {
driver = this.selectedNetIfConfig.getAccessPointWifiConfig().getDriver();
} else if (GwtWifiWirelessMode.netWifiWirelessModeAdHoc.equals(wifiMode)) {
driver = this.selectedNetIfConfig.getAdhocWifiConfig().getDriver();
} else if (GwtWifiWirelessMode.netWifiWirelessModeStation.equals(wifiMode)) {
driver = this.selectedNetIfConfig.getStationWifiConfig().getDriver();
}
// use previous value
gwtWifiConfig.setDriver(driver);
// radio mode
String radioValue = this.radio.getSelectedItemText();
for (GwtWifiRadioMode mode : GwtWifiRadioMode.values()) {
if (MessageUtils.get(mode.name()).equals(radioValue)) {
gwtWifiConfig.setRadioMode(mode.name());
}
}
// channels
Set<GwtWifiChannelModel> lSelectedChannels = this.selectionModel.getSelectedSet();
ArrayList<Integer> alChannels = new ArrayList<Integer>();
for (GwtWifiChannelModel item : lSelectedChannels) {
alChannels.add(new Integer(item.getChannel()));
}
if (alChannels.isEmpty()) {
alChannels.add(1);
}
gwtWifiConfig.setChannels(alChannels);
// security
String secValue = this.security.getSelectedItemText();
for (GwtWifiSecurity sec : GwtWifiSecurity.values()) {
if (MessageUtils.get(sec.name()).equals(secValue)) {
gwtWifiConfig.setSecurity(sec.name());
}
}
// Pairwise Ciphers
String pairWiseCiphersValue = this.pairwise.getSelectedItemText();
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
if (MessageUtils.get(ciphers.name()).equals(pairWiseCiphersValue)) {
gwtWifiConfig.setPairwiseCiphers(ciphers.name());
}
}
// Group Ciphers value
String groupCiphersValue = this.group.getSelectedItemText();
for (GwtWifiCiphers ciphers : GwtWifiCiphers.values()) {
if (MessageUtils.get(ciphers.name()).equals(groupCiphersValue)) {
gwtWifiConfig.setGroupCiphers(ciphers.name());
}
}
// bgscan
String bgscanModuleValue = this.bgscan.getSelectedItemText();
for (GwtWifiBgscanModule module : GwtWifiBgscanModule.values()) {
if (MessageUtils.get(module.name()).equals(bgscanModuleValue)) {
gwtWifiConfig.setBgscanModule(module.name());
}
}
// gwtWifiConfig.setBgscanRssiThreshold(rssi.getValue().intValue());
gwtWifiConfig.setBgscanShortInterval(Integer.parseInt(this.shortI.getText()));
gwtWifiConfig.setBgscanLongInterval(Integer.parseInt(this.longI.getText()));
// password
if (this.groupPassword.getValidationState().equals(ValidationState.NONE)) {
gwtWifiConfig.setPassword(this.password.getText());
}
// ping access point
gwtWifiConfig.setPingAccessPoint(this.radio1.getValue());
// ignore SSID
gwtWifiConfig.setIgnoreSSID(this.radio3.getValue());
return gwtWifiConfig;
}
Also used :
GwtWifiChannelModel(org.eclipse.kura.web.shared.model.GwtWifiChannelModel)
GwtWifiCiphers(org.eclipse.kura.web.shared.model.GwtWifiCiphers)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
GwtWifiWirelessMode(org.eclipse.kura.web.shared.model.GwtWifiWirelessMode)
ArrayList(java.util.ArrayList)
GwtWifiSecurity(org.eclipse.kura.web.shared.model.GwtWifiSecurity)
GwtWifiRadioMode(org.eclipse.kura.web.shared.model.GwtWifiRadioMode)
GwtWifiBgscanModule(org.eclipse.kura.web.shared.model.GwtWifiBgscanModule)
Example 5 with GwtWifiRadioMode
use of org.eclipse.kura.web.shared.model.GwtWifiRadioMode in project kura by eclipse.
the class GwtNetworkServiceImpl method getWifiConfig.
private WifiConfig getWifiConfig(GwtWifiConfig gwtWifiConfig) {
WifiConfig wifiConfig = null;
if (gwtWifiConfig != null) {
wifiConfig = new WifiConfig();
String mode = gwtWifiConfig.getWirelessMode();
if (mode != null && mode.equals(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name())) {
wifiConfig.setMode(WifiMode.MASTER);
} else if (mode != null && mode.equals(GwtWifiWirelessMode.netWifiWirelessModeStation.name())) {
wifiConfig.setMode(WifiMode.INFRA);
} else if (mode != null && mode.equals(GwtWifiWirelessMode.netWifiWirelessModeAdHoc.name())) {
wifiConfig.setMode(WifiMode.ADHOC);
} else {
wifiConfig.setMode(WifiMode.UNKNOWN);
}
// ssid
wifiConfig.setSSID(GwtSafeHtmlUtils.htmlUnescape(gwtWifiConfig.getWirelessSsid()));
// driver
wifiConfig.setDriver(gwtWifiConfig.getDriver());
// radio mode
GwtWifiRadioMode radioMode = gwtWifiConfig.getRadioModeEnum();
if (radioMode == GwtWifiRadioMode.netWifiRadioModeA) {
wifiConfig.setRadioMode(WifiRadioMode.RADIO_MODE_80211a);
wifiConfig.setHardwareMode("a");
} else if (radioMode.equals(GwtWifiRadioMode.netWifiRadioModeB)) {
wifiConfig.setRadioMode(WifiRadioMode.RADIO_MODE_80211b);
wifiConfig.setHardwareMode("b");
} else if (radioMode.equals(GwtWifiRadioMode.netWifiRadioModeBG)) {
wifiConfig.setRadioMode(WifiRadioMode.RADIO_MODE_80211g);
wifiConfig.setHardwareMode("g");
} else if (radioMode.equals(GwtWifiRadioMode.netWifiRadioModeBGN)) {
wifiConfig.setRadioMode(WifiRadioMode.RADIO_MODE_80211nHT20);
wifiConfig.setHardwareMode("n");
}
// channel
ArrayList<Integer> alChannels = gwtWifiConfig.getChannels();
if (alChannels != null) {
int[] channels = new int[alChannels.size()];
for (int i = 0; i < channels.length; i++) {
channels[i] = alChannels.get(i).intValue();
}
wifiConfig.setChannels(channels);
}
// security
wifiConfig.setSecurity(WifiSecurity.SECURITY_NONE);
String security = gwtWifiConfig.getSecurity();
if (security != null) {
if (security.equals(GwtWifiSecurity.netWifiSecurityWPA.name())) {
// wifiConfig.setSecurity(WifiSecurity.KEY_MGMT_PSK);
wifiConfig.setSecurity(WifiSecurity.SECURITY_WPA);
} else if (security.equals(GwtWifiSecurity.netWifiSecurityWPA2.name())) {
// wifiConfig.setSecurity(WifiSecurity.KEY_MGMT_PSK);
wifiConfig.setSecurity(WifiSecurity.SECURITY_WPA2);
} else if (security.equals(GwtWifiSecurity.netWifiSecurityWPA_WPA2.name())) {
// wifiConfig.setSecurity(WifiSecurity.KEY_MGMT_PSK);
wifiConfig.setSecurity(WifiSecurity.SECURITY_WPA_WPA2);
} else if (security.equals(GwtWifiSecurity.netWifiSecurityWEP.name())) {
// wifiConfig.setSecurity(WifiSecurity.PAIR_WEP104);
wifiConfig.setSecurity(WifiSecurity.SECURITY_WEP);
}
}
String pairwiseCiphers = gwtWifiConfig.getPairwiseCiphers();
if (pairwiseCiphers != null) {
if (pairwiseCiphers.equals(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name())) {
wifiConfig.setPairwiseCiphers(WifiCiphers.CCMP_TKIP);
} else if (pairwiseCiphers.equals(GwtWifiCiphers.netWifiCiphers_TKIP.name())) {
wifiConfig.setPairwiseCiphers(WifiCiphers.TKIP);
} else if (pairwiseCiphers.equals(GwtWifiCiphers.netWifiCiphers_CCMP.name())) {
wifiConfig.setPairwiseCiphers(WifiCiphers.CCMP);
}
}
String groupCiphers = gwtWifiConfig.getGroupCiphers();
if (groupCiphers != null) {
if (groupCiphers.equals(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name())) {
wifiConfig.setGroupCiphers(WifiCiphers.CCMP_TKIP);
} else if (groupCiphers.equals(GwtWifiCiphers.netWifiCiphers_TKIP.name())) {
wifiConfig.setGroupCiphers(WifiCiphers.TKIP);
} else if (groupCiphers.equals(GwtWifiCiphers.netWifiCiphers_CCMP.name())) {
wifiConfig.setGroupCiphers(WifiCiphers.CCMP);
}
}
// bgscan
String bgscanModule = gwtWifiConfig.getBgscanModule();
if (bgscanModule != null) {
WifiBgscanModule wifiBgscanModule = null;
if (bgscanModule.equals(GwtWifiBgscanModule.netWifiBgscanMode_NONE.name())) {
wifiBgscanModule = WifiBgscanModule.NONE;
} else if (bgscanModule.equals(GwtWifiBgscanModule.netWifiBgscanMode_SIMPLE.name())) {
wifiBgscanModule = WifiBgscanModule.SIMPLE;
} else if (bgscanModule.equals(GwtWifiBgscanModule.netWifiBgscanMode_LEARN.name())) {
wifiBgscanModule = WifiBgscanModule.LEARN;
}
int bgscanRssiThreshold = gwtWifiConfig.getBgscanRssiThreshold();
int bgscanShortInterval = gwtWifiConfig.getBgscanShortInterval();
int bgscanLongInterval = gwtWifiConfig.getBgscanLongInterval();
WifiBgscan wifiBgscan = new WifiBgscan(wifiBgscanModule, bgscanShortInterval, bgscanRssiThreshold, bgscanLongInterval);
wifiConfig.setBgscan(wifiBgscan);
}
// passkey
wifiConfig.setPasskey(gwtWifiConfig.getPassword());
// ping access point?
wifiConfig.setPingAccessPoint(gwtWifiConfig.pingAccessPoint());
// ignore SSID?
wifiConfig.setIgnoreSSID(gwtWifiConfig.ignoreSSID());
// broadcast SSID
wifiConfig.setBroadcast(!gwtWifiConfig.ignoreSSID());
}
return wifiConfig;
}
Also used :
WifiBgscanModule(org.eclipse.kura.net.wifi.WifiBgscanModule)
GwtWifiBgscanModule(org.eclipse.kura.web.shared.model.GwtWifiBgscanModule)
WifiConfig(org.eclipse.kura.net.wifi.WifiConfig)
GwtWifiConfig(org.eclipse.kura.web.shared.model.GwtWifiConfig)
WifiBgscan(org.eclipse.kura.net.wifi.WifiBgscan)
GwtWifiRadioMode(org.eclipse.kura.web.shared.model.GwtWifiRadioMode)
Aggregations
GwtWifiConfig (org.eclipse.kura.web.shared.model.GwtWifiConfig)6
GwtWifiRadioMode (org.eclipse.kura.web.shared.model.GwtWifiRadioMode)6
GwtWifiBgscanModule (org.eclipse.kura.web.shared.model.GwtWifiBgscanModule)5
ArrayList (java.util.ArrayList)4
GwtWifiCiphers (org.eclipse.kura.web.shared.model.GwtWifiCiphers)4
GwtWifiSecurity (org.eclipse.kura.web.shared.model.GwtWifiSecurity)4
AsyncCallback (com.google.gwt.user.client.rpc.AsyncCallback)2
List (java.util.List)2
GwtWifiChannelModel (org.eclipse.kura.web.shared.model.GwtWifiChannelModel)2
GwtWifiWirelessMode (org.eclipse.kura.web.shared.model.GwtWifiWirelessMode)2
GwtXSRFToken (org.eclipse.kura.web.shared.model.GwtXSRFToken)2
El (com.extjs.gxt.ui.client.core.El)1
ListLoadResult (com.extjs.gxt.ui.client.data.ListLoadResult)1
ModelData (com.extjs.gxt.ui.client.data.ModelData)1
BaseEvent (com.extjs.gxt.ui.client.event.BaseEvent)1
ButtonEvent (com.extjs.gxt.ui.client.event.ButtonEvent)1
ComponentEvent (com.extjs.gxt.ui.client.event.ComponentEvent)1
KeyListener (com.extjs.gxt.ui.client.event.KeyListener)1
GroupingStore (com.extjs.gxt.ui.client.store.GroupingStore)1
ContentPanel (com.extjs.gxt.ui.client.widget.ContentPanel)1
