diff -r fc7b30ed2058 -r 05bc53fe583b cmmanager/cppacketdataapplugin/src/cppacketdataapadvancedview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmmanager/cppacketdataapplugin/src/cppacketdataapadvancedview.cpp Tue Aug 31 15:35:44 2010 +0300 @@ -0,0 +1,1219 @@ +/* +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0"" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Control Panel packet data AP advanced settings view implementation. +* +*/ + +// System includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// User includes +#include "cpipv4filter.h" +#include "cpipv6filter.h" +#include "cppacketdataapadvancedview.h" + +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "cppacketdataapadvancedviewTraces.h" +#endif + +/*! + \class CpPacketDataApAdvancedView + \brief Implements the advanced settings view for packet data bearer + access points. +*/ + +// External function prototypes + +// Local constants + +// ======== LOCAL FUNCTIONS ======== + +// ======== MEMBER FUNCTIONS ======== + +/*! + Constructor. +*/ +CpPacketDataApAdvancedView::CpPacketDataApAdvancedView( + CmConnectionMethodShim *cmConnectionMethod, + QGraphicsItem *parent) : + CpBaseSettingView(0, parent), + mForm(0), + mModel(0), + mCmConnectionMethod(cmConnectionMethod), + mIpGroup(0), + mNetworkType(0), + mIpv4Automatic(0), + mIpv4Address(0), + mIpv4DnsAutomatic(0), + mIpv4DnsAddress1(0), + mIpv4DnsAddress2(0), + mIpv6DnsAutomatic(0), + mIpv6DnsAddress1(0), + mIpv6DnsAddress2(0), + mProxyGroup(0), + mProxyServer(0), + mProxyPort(0), + mMessageBox(0), + mIpv6Supported(false), + mCurrentNetworkType(NetworkTypeIpv4) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CPPACKETDATAAPADVANCEDVIEW_ENTRY); + + // Construct packet data AP advanced settings UI + mForm = new HbDataForm(); + this->setWidget(mForm); + mModel = new HbDataFormModel(mForm); + mForm->setModel(mModel); + + mIpv6Supported = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIPv6Supported); + + // Add advanced settings groups + createAdvancedSettings(); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CPPACKETDATAAPADVANCEDVIEW_EXIT); +} + +/*! + Destructor. +*/ +CpPacketDataApAdvancedView::~CpPacketDataApAdvancedView() +{ + OstTraceFunctionEntry0(DUP1_CPPACKETDATAAPADVANCEDVIEW_CPPACKETDATAAPADVANCEDVIEW_ENTRY); + + OstTraceFunctionExit0(DUP1_CPPACKETDATAAPADVANCEDVIEW_CPPACKETDATAAPADVANCEDVIEW_EXIT); +} + +/*! + Creates all advanced settings groups. +*/ +void CpPacketDataApAdvancedView::createAdvancedSettings() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_ENTRY); + + // Create settings groups + createIpGroup(); + createProxyGroup(); + + // Read values and update UI + updateIpGroup(); + updateProxyGroup(); + + // Connect signal to initialize settings item widgets + bool status = connect( + mForm, + SIGNAL(itemShown(const QModelIndex)), + this, + SLOT(setEditorPreferences(const QModelIndex))); + Q_ASSERT(status); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_EXIT); +} + +/*! + Creates the IP settings group. +*/ +void CpPacketDataApAdvancedView::createIpGroup() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPGROUP_ENTRY); + + // IP settings group + mIpGroup = new CpSettingFormItemData( + HbDataFormModelItem::GroupItem, + hbTrId("txt_occ_subhead_ip_settings")); + mModel->appendDataFormItem(mIpGroup); + + if (mIpv6Supported) { + // IPv6 supported + // Network type + mNetworkType = new CpSettingFormItemData( + HbDataFormModelItem::ComboBoxItem, + hbTrId("txt_occ_setlabel_network_type")); + QStringList networkTypeList; + networkTypeList + << hbTrId("txt_occ_setlabel_network_type_val_ipv4") + << hbTrId("txt_occ_setlabel_network_type_val_ipv6"); + mNetworkType->setContentWidgetData("items", networkTypeList); + mForm->addConnection( + mNetworkType, + SIGNAL(currentIndexChanged(int)), + this, + SLOT(changeNetworkType(int))); + mNetworkType->setContentWidgetData("objectName", "networkTypeCB"); + mIpGroup->appendChild(mNetworkType); + + mCurrentNetworkType = getNetworkType(); + if (mCurrentNetworkType == NetworkTypeIpv4) { + // IPv4 + createIpv4SettingItems(); + } else { + // IPv6 + createIpv6SettingItems(); + } + } else { + // IPv6 not supported, create IPv4 settings items + createIpv4SettingItems(); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPGROUP_EXIT); +} + +/*! + Reads attribute values and updates the IP settings group. +*/ +void CpPacketDataApAdvancedView::updateIpGroup() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_UPDATEIPGROUP_ENTRY); + + // Network type + if (mNetworkType) { + // Every time update is called we check if network type (IPv4/IPv6) + // has changed and update items on UI if necessary. + + // Get network type from CommsDat + NetworkType newNetworkType = getNetworkType(); + if (newNetworkType != mCurrentNetworkType) { + // Network type has changed, update UI + if (newNetworkType == NetworkTypeIpv6) { + // IPv4 -> IPv6 + deleteIpv4SettingItems(); + createIpv6SettingItems(); + } else { + // IPv6 -> IPv4 + deleteIpv6SettingItems(); + createIpv4SettingItems(); + } + mCurrentNetworkType = newNetworkType; + } + mNetworkType->setContentWidgetData("currentIndex", newNetworkType); + } + + // Phone IP address (IPv4) + // "Automatic" checkbox + if (mIpv4Automatic) { + bool ipAddressFromServer = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::PacketDataIPAddrFromServer); + Qt::CheckState state = Qt::Unchecked; + if (ipAddressFromServer) { + state = Qt::Checked; + } + mIpv4Automatic->setContentWidgetData("checkState", state); + + // Enable/disable user defined IP address fields + enableIpv4AddressFields(state); + } + + // Phone IP address (IPv4) + if (mIpv4Address) { + QString string = getIpAddress(CMManagerShim::CmIPAddress); + mIpv4Address->setContentWidgetData("text", string); + } + + // IPv4 DNS addresses + // "Automatic" checkbox + if (mIpv4DnsAutomatic) { + Qt::CheckState state = Qt::Unchecked; + if (mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer)) { + state = Qt::Checked; + } + mIpv4DnsAutomatic->setContentWidgetData("checkState", state); + + // Enable/disable user defined DNS address fields + enableIpv4DnsFields(state); + } + + // IPv4 primary DNS address + if (mIpv4DnsAddress1) { + QString string = getIpAddress(CMManagerShim::CmIPNameServer1); + mIpv4DnsAddress1->setContentWidgetData("text", string); + } + + // IPv4 secondary DNS address + if (mIpv4DnsAddress2) { + QString string = getIpAddress(CMManagerShim::CmIPNameServer2); + mIpv4DnsAddress2->setContentWidgetData("text", string); + } + + // IPv6 DNS addresses + // Automatic/well-known/user defined combobox + if (mIpv6DnsAutomatic) { + uint type = getIpv6DnsType(); + mIpv6DnsAutomatic->setContentWidgetData("currentIndex", type); + + // Enable/disable user defined DNS address fields + enableIpv6DnsFields(type); + } + + // IPv6 primary DNS address + if (mIpv6DnsAddress1) { + QString string = getIpAddress(CMManagerShim::CmIP6NameServer1); + mIpv6DnsAddress1->setContentWidgetData("text", string); + } + + // IPv6 secondary DNS address + if (mIpv6DnsAddress2) { + QString string = getIpAddress(CMManagerShim::CmIP6NameServer2); + mIpv6DnsAddress2->setContentWidgetData("text", string); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_UPDATEIPGROUP_EXIT); +} + +/*! + Creates the IPv4 setting items. +*/ +void CpPacketDataApAdvancedView::createIpv4SettingItems() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPV4SETTINGITEMS_ENTRY); + + // Phone IP address + // "Automatic" checkbox + mIpv4Automatic = new CpSettingFormItemData( + HbDataFormModelItem::CheckBoxItem, + hbTrId("txt_occ_setlabel_phone_ip_address")); + mIpv4Automatic->setContentWidgetData( + "text", + hbTrId("txt_occ_setlabel_val_automatic")); + mForm->addConnection( + mIpv4Automatic, + SIGNAL(stateChanged(int)), + this, + SLOT(changeIpv4AddressMode(int))); + mIpv4Automatic->setContentWidgetData("objectName", "ipv4AutomaticCB"); + mIpGroup->appendChild(mIpv4Automatic); + + // Phone IP address + mIpv4Address = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_phone_ip_address")); + mForm->addConnection( + mIpv4Address, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4Address())); + mIpv4Address->setContentWidgetData("objectName", "ipv4AddressEdit"); + mIpGroup->appendChild(mIpv4Address); + + // DNS addresses + // "Automatic" checkbox + mIpv4DnsAutomatic = new CpSettingFormItemData( + HbDataFormModelItem::CheckBoxItem, + hbTrId("txt_occ_setlabel_dns_addresses")); + mIpv4DnsAutomatic->setContentWidgetData( + "text", + hbTrId("txt_occ_setlabel_val_automatic")); + mForm->addConnection( + mIpv4DnsAutomatic, + SIGNAL(stateChanged(int)), + this, + SLOT(changeIpv4DnsMode(int))); + mIpv4DnsAutomatic->setContentWidgetData("objectName", "ipv4DnsAutomaticCB"); + mIpGroup->appendChild(mIpv4DnsAutomatic); + + // Primary DNS address + mIpv4DnsAddress1 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_primary_name_server")); + mForm->addConnection( + mIpv4DnsAddress1, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4PrimaryDnsAddress())); + mIpv4DnsAddress1->setContentWidgetData("objectName", "ipv4DnsAddress1Edit"); + mIpGroup->appendChild(mIpv4DnsAddress1); + + // Secondary DNS address + mIpv4DnsAddress2 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_secondary_name_server")); + mForm->addConnection( + mIpv4DnsAddress2, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4SecondaryDnsAddress())); + mIpv4DnsAddress2->setContentWidgetData("objectName", "ipv4DnsAddress2Edit"); + mIpGroup->appendChild(mIpv4DnsAddress2); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPV4SETTINGITEMS_EXIT); +} + +/*! + Deletes the IPv4 setting items. +*/ +void CpPacketDataApAdvancedView::deleteIpv4SettingItems() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_DELETEIPV4SETTINGITEMS_ENTRY); + + // Phone IP address + // "Automatic" checkbox + if (mIpv4Automatic) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv4Automatic)); + mIpv4Automatic = NULL; + } + + // Phone IP address + if (mIpv4Address) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv4Address)); + mIpv4Address = NULL; + } + + // DNS addresses + // "Automatic" checkbox + if (mIpv4DnsAutomatic) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv4DnsAutomatic)); + mIpv4DnsAutomatic = NULL; + } + + // Primary DNS address + if (mIpv4DnsAddress1) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv4DnsAddress1)); + mIpv4DnsAddress1 = NULL; + } + + // Secondary DNS address + if (mIpv4DnsAddress2) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv4DnsAddress2)); + mIpv4DnsAddress2 = NULL; + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_DELETEIPV4SETTINGITEMS_EXIT); +} + +/*! + Creates the IPv6 setting items. +*/ +void CpPacketDataApAdvancedView::createIpv6SettingItems() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPV6SETTINGITEMS_ENTRY); + + // DNS addresses + // Automatic/well-known/user defined combobox + mIpv6DnsAutomatic = new CpSettingFormItemData( + HbDataFormModelItem::ComboBoxItem, + hbTrId("txt_occ_setlabel_dns_addresses")); + QStringList dnsModeList; + // Order of the list must match the Ipv6DnsType enum + dnsModeList + << hbTrId("txt_occ_setlabel_val_automatic") + << hbTrId("txt_occ_setlabel_dns_addresses_val_wellknown") + << hbTrId("txt_occ_setlabel_dns_addresses_val_user_defined"); + mIpv6DnsAutomatic->setContentWidgetData("items", dnsModeList); + mForm->addConnection( + mIpv6DnsAutomatic, + SIGNAL(currentIndexChanged(int)), + this, + SLOT(changeIpv6DnsMode(int))); + mIpv6DnsAutomatic->setContentWidgetData("objectName", "ipv6DnsAutomaticCB"); + mIpGroup->appendChild(mIpv6DnsAutomatic); + + // Primary DNS address + mIpv6DnsAddress1 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_primary_name_server")); + mForm->addConnection( + mIpv6DnsAddress1, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv6PrimaryDnsAddress())); + mIpv6DnsAddress1->setContentWidgetData("objectName", "ipv6DnsAddress1Edit"); + mIpGroup->appendChild(mIpv6DnsAddress1); + + // Secondary DNS address + mIpv6DnsAddress2 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_secondary_name_server")); + mForm->addConnection( + mIpv6DnsAddress2, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv6SecondaryDnsAddress())); + mIpv6DnsAddress2->setContentWidgetData("objectName", "ipv6DnsAddress2Edit"); + mIpGroup->appendChild(mIpv6DnsAddress2); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CREATEIPV6SETTINGITEMS_EXIT); +} + +/*! + Deletes the IPv6 setting items. +*/ +void CpPacketDataApAdvancedView::deleteIpv6SettingItems() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_DELETEIPV6SETTINGITEMS_ENTRY); + + // DNS addresses + // Automatic/well-known/user defined combobox + if (mIpv6DnsAutomatic) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv6DnsAutomatic)); + mIpv6DnsAutomatic = NULL; + } + + // Primary DNS address + if (mIpv6DnsAddress1) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv6DnsAddress1)); + mIpv6DnsAddress1 = NULL; + } + + // Secondary DNS address + if (mIpv6DnsAddress2) { + mIpGroup->removeChild(mIpGroup->indexOf(mIpv6DnsAddress2)); + mIpv6DnsAddress2 = NULL; + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_DELETEIPV6SETTINGITEMS_EXIT); +} + +/*! + Creates the proxy settings group. +*/ +void CpPacketDataApAdvancedView::createProxyGroup() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CREATEPROXYGROUP_ENTRY); + + // Proxy settings group + mProxyGroup = new CpSettingFormItemData( + HbDataFormModelItem::GroupItem, + hbTrId("txt_occ_subhead_proxy_settings")); + mModel->appendDataFormItem(mProxyGroup); + + // Proxy server address + mProxyServer = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_proxy_server_address")); + mForm->addConnection( + mProxyServer, + SIGNAL(editingFinished()), + this, + SLOT(changeProxyServer())); + mProxyServer->setContentWidgetData("objectName", "proxyServerEdit"); + mProxyGroup->appendChild(mProxyServer); + + // Proxy port number + mProxyPort = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_proxy_port_number")); + mForm->addConnection( + mProxyPort, + SIGNAL(editingFinished()), + this, + SLOT(changeProxyPort())); + mProxyPort->setContentWidgetData("objectName", "proxyPortEdit"); + mProxyGroup->appendChild(mProxyPort); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CREATEPROXYGROUP_EXIT); +} + +/*! + Reads attribute values and updates the proxy settings group. +*/ +void CpPacketDataApAdvancedView::updateProxyGroup() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_UPDATEPROXYGROUP_ENTRY); + + // Proxy server address + QString serverAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmProxyServerName); + mProxyServer->setContentWidgetData("text", serverAddress); + + // Proxy port number + uint portNumber = mCmConnectionMethod->getIntAttribute( + CMManagerShim::CmProxyPortNumber); + if (portNumber > 0) { + mProxyPort->setContentWidgetData("text", QVariant(portNumber)); + } else { + mProxyPort->setContentWidgetData("text", ""); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_UPDATEPROXYGROUP_EXIT); +} + +/*! + Reads network type (IPv4/IPv6) from CommsDat. +*/ +CpPacketDataApAdvancedView::NetworkType CpPacketDataApAdvancedView::getNetworkType() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_GETNETWORKTYPE_ENTRY); + + uint networkType = mCmConnectionMethod->getIntAttribute( + CMManagerShim::PacketDataPDPType); + + if (networkType == RPacketContext::EPdpTypeIPv6) { + OstTraceFunctionExit0(DUP1_CPPACKETDATAAPADVANCEDVIEW_GETNETWORKTYPE_EXIT); + return NetworkTypeIpv6; + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_GETNETWORKTYPE_EXIT); + return NetworkTypeIpv4; +} + +/*! + Reads an IP address from CommsDat with given attribute. If string is + empty, a zero address (0.0.0.0 or 0:0:0:0:0:0:0:0) is returned. +*/ +QString CpPacketDataApAdvancedView::getIpAddress( + CMManagerShim::ConnectionMethodAttribute attribute) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_GETIPADDRESS_ENTRY); + + QString ipAddress = mCmConnectionMethod->getStringAttribute(attribute); + + if (ipAddress.isEmpty()) { + // String is empty, return a zero address instead + switch (attribute) { + case CMManagerShim::CmIPAddress: + case CMManagerShim::CmIPNameServer1: + case CMManagerShim::CmIPNameServer2: + // IPv4 address + ipAddress = CMManagerShim::UnspecifiedIpv4Address; + break; + + case CMManagerShim::CmIP6NameServer1: + case CMManagerShim::CmIP6NameServer2: + // IPv6 address + ipAddress = CMManagerShim::DynamicIpv6Address; + break; + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_GETIPADDRESS_EXIT); + return ipAddress; +} + +/*! + Resolves IPv6 DNS address type. +*/ +CpPacketDataApAdvancedView::Ipv6DnsType CpPacketDataApAdvancedView::getIpv6DnsType() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_GETIPV6DNSTYPE_ENTRY); + + // Read "DNS address from server" flag + bool dnsAddressFromServer = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer); + + // Read IPv6 DNS addresses from CommsDat + QString primaryAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmIP6NameServer1); + QString secondaryAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmIP6NameServer2); + + // Resolve IPv6 DNS address type + Ipv6DnsType type = Ipv6DnsTypeUserDefined; + if (dnsAddressFromServer) { + // Automatic + type = Ipv6DnsTypeAutomatic; + } else if (primaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer1 + && secondaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer2) { + // Well-known IPv6 DNS addresses + type = Ipv6DnsTypeWellKnown; + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_GETIPV6DNSTYPE_EXIT); + return type; +} + +/*! + Sets IPv4 address field enabled/disabled. +*/ +void CpPacketDataApAdvancedView::enableIpv4AddressFields(int state) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_ENTRY); + + if (state == Qt::Checked) { + // Automatic, disable text field + if (mIpv4Address) { + mIpv4Address->setEnabled(false); + } + } else { + // User defined, enable text field + if (mIpv4Address) { + mIpv4Address->setEnabled(true); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_EXIT); +} + +/*! + Sets IPv4 DNS address fields enabled/disabled. +*/ +void CpPacketDataApAdvancedView::enableIpv4DnsFields(int state) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_ENTRY); + + if (state == Qt::Checked) { + // Automatic, disable text fields + if (mIpv4DnsAddress1) { + mIpv4DnsAddress1->setEnabled(false); + } + if (mIpv4DnsAddress2) { + mIpv4DnsAddress2->setEnabled(false); + } + } else { + // User defined, enable text fields + if (mIpv4DnsAddress1) { + mIpv4DnsAddress1->setEnabled(true); + } + if (mIpv4DnsAddress2) { + mIpv4DnsAddress2->setEnabled(true); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_EXIT); +} + +/*! + Sets IPv6 DNS address fields enabled/disabled. +*/ +void CpPacketDataApAdvancedView::enableIpv6DnsFields(int selectionIndex) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_ENTRY); + + // Check combobox value + if (selectionIndex == Ipv6DnsTypeUserDefined) { + // User-defined, enable text fields + if (mIpv6DnsAddress1) { + mIpv6DnsAddress1->setEnabled(true); + } + if (mIpv6DnsAddress2) { + mIpv6DnsAddress2->setEnabled(true); + } + } else { + // Automatic or well-known, disable text fields + if (mIpv6DnsAddress1) { + mIpv6DnsAddress1->setEnabled(false); + } + if (mIpv6DnsAddress2) { + mIpv6DnsAddress2->setEnabled(false); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_EXIT); +} + +/*! + Validates an IP address and saves it to CommsDat in case it was a valid + address or an empty string. In case the address is not valid, an error + note is shown to the user and previous setting is restored to the UI. +*/ +bool CpPacketDataApAdvancedView::validateAndSaveIpAddress( + HbDataFormModelItem *item, + CMManagerShim::ConnectionMethodAttribute attribute, + QAbstractSocket::NetworkLayerProtocol protocol) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_ENTRY); + + bool success = false; + + // Check address + QString address = item->contentWidgetData("text").toString(); + QHostAddress hostAddress; + if (hostAddress.setAddress(address) + && hostAddress.protocol() == protocol) { + // Proper address, convert to lower case (IPv6) + address = hostAddress.toString().toLower(); + } else if (address.isEmpty()) { + // Empty string, replace with 0.0.0.0 or 0:0:0:0:0:0:0:0 + if (protocol == QAbstractSocket::IPv4Protocol) { + address = CMManagerShim::UnspecifiedIpv4Address; + } else { + address = CMManagerShim::DynamicIpv6Address; + } + } else { + // Invalid address + address.clear(); + } + + if (!address.isEmpty()) { + // Save to CommsDat + mCmConnectionMethod->setStringAttribute(attribute, address); + if (tryUpdate()) { + success = true; + item->setContentWidgetData("text", address); + } + } else { + // Inform user of invalid name + showMessageBox( + HbMessageBox::MessageTypeInformation, + hbTrId("txt_occ_info_invalid_input")); + // Restore previous setting + address = getIpAddress(attribute); + item->setContentWidgetData("text", address); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_EXIT); + return success; +} + +/*! + Shows message box with "OK" button using given text. +*/ +void CpPacketDataApAdvancedView::showMessageBox( + HbMessageBox::MessageBoxType type, + const QString &text) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_SHOWMESSAGEBOX_ENTRY); + + // Create a message box + mMessageBox = QSharedPointer(new HbMessageBox(type)); + mMessageBox->setText(text); + mMessageBox->setModal(true); + mMessageBox->setTimeout(HbPopup::NoTimeout); + mMessageBox->open(); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_SHOWMESSAGEBOX_EXIT); +} + +/*! + Tries to update connection method changes to CommsDat. + Returns "true" if success, "false" if some error happened. +*/ +bool CpPacketDataApAdvancedView::tryUpdate() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_TRYUPDATE_ENTRY); + + // Try update + try { + mCmConnectionMethod->update(); + } + catch (const std::exception&) { + // Handle error + handleUpdateError(); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_TRYUPDATE_EXIT); + return false; + } + + OstTraceFunctionExit0(DUP1_CPPACKETDATAAPADVANCEDVIEW_TRYUPDATE_EXIT); + return true; +} + +/*! + Handles failed CommsDat update. + */ +void CpPacketDataApAdvancedView::handleUpdateError() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_HANDLEUPDATEERROR_ENTRY); + + // Show error note to user + showMessageBox( + HbMessageBox::MessageTypeWarning, + hbTrId("txt_occ_info_unable_to_save_setting")); + // Reload settings from CommsDat and update UI + try { + mCmConnectionMethod->refresh(); + } + catch (const std::exception&) { + // Ignore error from refresh. Most likely this will not happen, but + // if it does, there isn't very much we can do. + OstTrace0( + TRACE_ERROR, + CPPACKETDATAAPPADVANCEDVIEW_HANDLEUPDATEERROR, + "Refresh failed"); + }; + updateIpGroup(); + updateProxyGroup(); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_HANDLEUPDATEERROR_EXIT); +} + +/*! + Initializes all settings groups. +*/ +void CpPacketDataApAdvancedView::setEditorPreferences(const QModelIndex index) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_SETEDITORPREFERENCES_ENTRY); + + HbDataFormViewItem *viewItem = qobject_cast + (mForm->itemByIndex(index)); + HbDataFormModelItem *modelItem = mModel->itemFromIndex(index); + + if (modelItem == mIpv4Address + || modelItem == mIpv4DnsAddress1 + || modelItem == mIpv4DnsAddress2 + || modelItem == mIpv6DnsAddress1 + || modelItem == mIpv6DnsAddress2 + || modelItem == mProxyServer + || modelItem == mProxyPort) { + // HbLineEdit items, get editor and editor interface + HbLineEdit *edit = qobject_cast + (viewItem->dataItemContentWidget()); + HbEditorInterface editorInterface(edit); + + if (modelItem == mIpv4Address + || modelItem == mIpv4DnsAddress1 + || modelItem == mIpv4DnsAddress2) { + // IPv4 IP address + editorInterface.setMode(HbInputModeNumeric); + editorInterface.setFilter(CpIpv4Filter::instance()); + edit->setMaxLength(CMManagerShim::CmIP4AddressLength); + } else if (modelItem == mIpv6DnsAddress1 + || modelItem == mIpv6DnsAddress2) { + // IPv6 IP address + editorInterface.setInputConstraints( + HbEditorConstraintLatinAlphabetOnly); + editorInterface.setFilter(CpIpv6Filter::instance()); + edit->setInputMethodHints( + Qt::ImhNoPredictiveText + | Qt::ImhPreferLowercase); + edit->setMaxLength(CMManagerShim::CmIP6NameServerLength); + } else if (modelItem == mProxyServer) { + // Proxy server address + editorInterface.setMode(HbInputModeNone); + editorInterface.setInputConstraints( + HbEditorConstraintLatinAlphabetOnly); + editorInterface.setFilter(HbUrlFilter::instance()); + editorInterface.setEditorClass(HbInputEditorClassUrl); + editorInterface.setDigitType(HbDigitTypeNone); + edit->setInputMethodHints( + Qt::ImhNoPredictiveText + | Qt::ImhPreferLowercase); + edit->setMaxLength(CMManagerShim::CmProxyServerNameLength); + } else { /* mProxyPort */ + // Proxy port number + editorInterface.setMode(HbInputModeNumeric); + edit->setInputMethodHints(Qt::ImhDigitsOnly); + edit->setMaxLength(CMManagerShim::CmProxyPortNumberLength); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_SETEDITORPREFERENCES_EXIT); +} + +/*! + Handles change to network type (IPv4/IPv6). +*/ +void CpPacketDataApAdvancedView::changeNetworkType(int type) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGENETWORKTYPE_ENTRY); + + // Save network type to CommsDat + int pdpType; + if (type == NetworkTypeIpv6) { + pdpType = RPacketContext::EPdpTypeIPv6; + } else { + pdpType = RPacketContext::EPdpTypeIPv4; + } + mCmConnectionMethod->setIntAttribute( + CMManagerShim::PacketDataPDPType, + pdpType); + if (tryUpdate()) + { + // This will handle updating the UI with correct setting items + updateIpGroup(); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGENETWORKTYPE_EXIT); +} + +/*! + Handles change to IPv4 address mode (automatic/user defined). +*/ +void CpPacketDataApAdvancedView::changeIpv4AddressMode(int state) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_ENTRY); + + bool ipv4AddressFromServer; + if (state == Qt::Checked) { + ipv4AddressFromServer = true; + } else { + ipv4AddressFromServer = false; + } + + if (!ipv4AddressFromServer + && getIpAddress(CMManagerShim::CmIPAddress) == + CMManagerShim::UnspecifiedIpv4Address) { + // User defined IP address selected, but no valid address is stored. + // Just enable the UI IP editors, because CMManager will update the + // "IP address from server" flag by itself when a valid IP address + // is stored. + enableIpv4AddressFields(state); + } else { + // Save setting to CommsDat + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPAddrFromServer, + ipv4AddressFromServer); + if (tryUpdate()) { + enableIpv4AddressFields(state); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_EXIT); +} + +/*! + Saves IPv4 address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeIpv4Address() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4ADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4Address, + CMManagerShim::CmIPAddress, + QAbstractSocket::IPv4Protocol)) { + // In case the IP address is empty or 0.0.0.0, CMManager changes the + // "IP address from server" flag to true. We need to refresh the UI to + // make sure we are in sync. + updateIpGroup(); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4ADDRESS_EXIT); +} + +/*! + Handles change to IPv4 DNS mode (automatic/user defined). +*/ +void CpPacketDataApAdvancedView::changeIpv4DnsMode(int state) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4DNSMODE_ENTRY); + + bool dnsAddressFromServer; + if (state == Qt::Checked) { + dnsAddressFromServer = true; + } else { + dnsAddressFromServer = false; + } + // Save setting to CommsDat + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + dnsAddressFromServer); + if (tryUpdate()) { + enableIpv4DnsFields(state); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4DNSMODE_EXIT); +} + +/*! + Saves IPv4 primary DNS address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeIpv4PrimaryDnsAddress() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4DnsAddress1, + CMManagerShim::CmIPNameServer1, + QAbstractSocket::IPv4Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0.0.0.0, CMManager will + // check secondary DNS address and in case it is a valid address, + // move it to the primary DNS address. We need to refresh the + // UI to make sure we are in sync. If tryUpdate() fails it does + // the refresh automatically, so only success case is handled + // here. + updateIpGroup(); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_EXIT); +} + +/*! + Saves IPv4 secondary DNS address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeIpv4SecondaryDnsAddress() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4DnsAddress2, + CMManagerShim::CmIPNameServer2, + QAbstractSocket::IPv4Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0.0.0.0, CMManager will + // write the address there instead of secondary DNS address, so we + // need to refresh the UI to make sure we are in sync. If + // tryUpdate() fails it does the refresh automatically, so only + // success case is handled here. + updateIpGroup(); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_EXIT); +} + +/*! + Handles change to IPv6 DNS mode (automatic/well-known/user defined). +*/ +void CpPacketDataApAdvancedView::changeIpv6DnsMode(int state) +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6DNSMODE_ENTRY); + + // Update "DNS address from server" flag + if (state == Ipv6DnsTypeAutomatic) { + // Automatic + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + true); + } else { + // User defined or well-known address + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + + if (state == Ipv6DnsTypeWellKnown) { + // Well-known address, set DNS addresses and update UI + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmIP6NameServer1, + CMManagerShim::KnownIpv6NameServer1); + mIpv6DnsAddress1->setContentWidgetData( + "text", + CMManagerShim::KnownIpv6NameServer1); + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmIP6NameServer2, + CMManagerShim::KnownIpv6NameServer2); + mIpv6DnsAddress2->setContentWidgetData( + "text", + CMManagerShim::KnownIpv6NameServer2); + } + } + + if (tryUpdate()) { + enableIpv6DnsFields(state); + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6DNSMODE_EXIT); +} + +/*! + Saves IPv6 primary DNS address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeIpv6PrimaryDnsAddress() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv6DnsAddress1, + CMManagerShim::CmIP6NameServer1, + QAbstractSocket::IPv6Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, + // CMManager will check secondary DNS address and in case it is a + // valid address, move it to the primary DNS address. We need to + // refresh the UI to make sure we are in sync. If tryUpdate() + // fails it does the refresh automatically, so only success case + // is handled here. + updateIpGroup(); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_EXIT); +} + +/*! + Saves IPv6 secondary DNS address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeIpv6SecondaryDnsAddress() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv6DnsAddress2, + CMManagerShim::CmIP6NameServer2, + QAbstractSocket::IPv6Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, + // CMManager will write the address there instead of secondary DNS + // address, so we need to refresh the UI to make sure we are in + // sync. If tryUpdate() fails it does the refresh automatically, + // so only success case is handled here. + updateIpGroup(); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_EXIT); +} + +/*! + Saves proxy server address to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeProxyServer() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEPROXYSERVER_ENTRY); + + QString proxyServer = mProxyServer->contentWidgetData("text").toString(); + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmProxyServerName, + proxyServer); + (void)tryUpdate(); + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEPROXYSERVER_EXIT); +} + +/*! + Saves proxy port to CommsDat. +*/ +void CpPacketDataApAdvancedView::changeProxyPort() +{ + OstTraceFunctionEntry0(CPPACKETDATAAPADVANCEDVIEW_CHANGEPROXYPORT_ENTRY); + + uint proxyPort = mProxyPort->contentWidgetData("text").toInt(); + if (proxyPort <= 65535) { + if (proxyPort == 0) { + // Don't show zero + mProxyPort->setContentWidgetData("text", ""); + } + mCmConnectionMethod->setIntAttribute( + CMManagerShim::CmProxyPortNumber, + proxyPort); + (void)tryUpdate(); + } else { + // Inform user of invalid value + showMessageBox( + HbMessageBox::MessageTypeInformation, + hbTrId("txt_occ_info_invalid_input")); + // Restore previous setting + proxyPort = mCmConnectionMethod->getIntAttribute( + CMManagerShim::CmProxyPortNumber); + if (proxyPort > 0) { + mProxyPort->setContentWidgetData("text", QVariant(proxyPort)); + } else { + mProxyPort->setContentWidgetData("text", ""); + } + } + + OstTraceFunctionExit0(CPPACKETDATAAPADVANCEDVIEW_CHANGEPROXYPORT_EXIT); +}