--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/securitysettings/cpeapuiplugins/cpeaptlsmethodsui/src/cpeaptlsmethodsui.cpp Tue Aug 31 15:16:37 2010 +0300
@@ -0,0 +1,985 @@
+/*
+ * 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 QT UI for TLS-based EAP methods configuration
+ *
+ */
+
+/*
+ * %version: 24 %
+ */
+
+// System includes
+#include <HbDataForm>
+#include <HbDataFormModel>
+#include <HbDataFormViewItem>
+#include <HbParameterLengthLimiter>
+#include <HbMessageBox>
+#include <HbAction>
+#include <HbLineEdit>
+#include <cpsettingformitemdata.h>
+#include <cpitemdatahelper.h>
+#include <eapqtvalidator.h>
+#include <eapqtexpandedeaptype.h>
+#include <eapqtcertificateinfo.h>
+#include <cppluginutility.h>
+
+// User includes
+#include "cpeapciphersuiteui.h"
+#include "cpeaptlsmethodsui.h"
+#include "cpeaptlsmethodsinnereapui.h"
+
+/*!
+ * \class CpEapTlsMethodsUi
+ * \brief Implementes TLS based methods configuration ui.
+ */
+
+// External function prototypes
+
+// Local constants
+
+/*!
+ * ComboBox index is unkown
+ */
+static const int UnknownIndex = -1;
+/*!
+ * Default index for ComboBox, used if no value has been stored
+ */
+static const int DefaultIndex = 0;
+/*!
+ * Index of 'Not in use'in certificate selection lists.
+ */
+static const int NotInUseIndex = 0;
+
+// ======== LOCAL FUNCTIONS ========
+
+// ======== MEMBER FUNCTIONS ========
+
+/*!
+ * Constructor.
+ *
+ * @param bearer Bearer type of the accessed configuration.
+ * @param iapId IAP ID of the accessed configuration.
+ * @param plugin Plugin.
+ * @param outerHandle Outer handle.
+ */
+
+CpEapTlsMethodsUi::CpEapTlsMethodsUi(
+ const EapQtConfigInterface::EapBearerType bearer,
+ const int iapId,
+ const EapQtPluginInfo &plugin,
+ const EapQtPluginHandle& outerHandle) :
+ mConfigIf(NULL),
+ mPluginInfo(plugin),
+ mOuterHandle(outerHandle),
+ mForm(NULL),
+ mModel(NULL),
+ mItemDataHelper(NULL),
+ mGroupItem(NULL),
+ mUsernameAutomatic(NULL),
+ mUsername(NULL),
+ mRealmAutomatic(NULL),
+ mRealm(NULL),
+ mCaCertAutomatic(NULL),
+ mCaCert(NULL),
+ mPeapVersion(NULL),
+ mInnerEapType(NULL),
+ mGroupItemCs(NULL),
+ mCurrentUserCert(0),
+ mCurrentAuthorityCert(0),
+ mCurrentPeapVersion(0),
+ mCurrentInnerPlugin(0),
+ mInnerEapMschapv2(0),
+ mInnerEapGtc(0),
+ mDefaultPluginInUse(false)
+{
+ qDebug("CpEapTlsMethodsUi::CpEapTlsMethodsUi()");
+
+ // IAP must be valid in construction (check includes
+ // EapQtConfigInterface::IapIdUndefined)
+ if (iapId < 0) {
+ QT_THROW(std::bad_alloc());
+ // scoped pointer gets deleted automaticaly on exception
+ }
+
+ // Get EAP config interface
+ mConfigIf.reset(new EapQtConfigInterface(bearer, iapId));
+
+ // Request supported inner EAP types
+ mPlugins.append(mConfigIf->supportedInnerTypes(mPluginInfo.pluginHandle()));
+
+ // Create UI
+ createUi();
+}
+
+/*!
+ * Destructor.
+ */
+CpEapTlsMethodsUi::~CpEapTlsMethodsUi()
+{
+ qDebug("CpEapTlsMethodsUi::~CpEapTlsMethodsUi()");
+
+ // mEapQtConfigInterface: scoped pointer deleted automatically
+ // mValidatorRealm: scoped pointer deleted automatically
+ // mValidatorUsername: scoped pointer deleted automatically
+}
+
+/*!
+ * Calls inner UI instance
+ *
+ * @return pointer to inner UI instance
+ */
+CpBaseSettingView *CpEapTlsMethodsUi::innerUiInstance()
+{
+ return mConfigIf->uiInstance(mPluginInfo.pluginHandle(),
+ mPlugins.at(mCurrentInnerPlugin).pluginHandle());
+}
+
+/*!
+ * Creates TLS based methods UI and initilizes settings read via
+ * EapQtConfigInterface
+ */
+void CpEapTlsMethodsUi::createUi()
+{
+ qDebug("CpEapTlsMethodsUi::createUi()");
+
+ // Read EAP Configurations
+ bool configurationRead = mConfigIf->readConfiguration(mOuterHandle, mPluginInfo.pluginHandle(),
+ mEapConfig);
+ if (!configurationRead) {
+ qDebug("CpEapTlsMethodsUi::createUi - read configuration failed.");
+ }
+
+ // Construct TLS based methods settings UI
+ mForm = new HbDataForm();
+ this->setWidget(mForm);
+ CpPluginUtility::addCpItemPrototype(mForm);
+ mModel = new HbDataFormModel(mForm);
+
+ // Create settings group
+ mGroupItem = new HbDataFormModelItem(HbDataFormModelItem::GroupItem,
+ HbParameterLengthLimiter(
+ hbTrId("txt_occ_subhead_eap_module_settings")).arg(
+ mPluginInfo.localizationId()));
+ mModel->appendDataFormItem(mGroupItem);
+
+ // The parameter given as 0 is a HbDataForm pointer, not parent
+ mItemDataHelper = new CpItemDataHelper(0);
+ mItemDataHelper->setParent(this);
+
+ // Create method specific UI
+ if (mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginEapTls) {
+ createTlsUi();
+ }
+ else if (mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginEapTtls) {
+ createTtlsUi();
+ }
+ else if (mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginPeap) {
+ createPeapUi();
+ }
+ else {
+ qDebug("CpEapTlsMethodsUi::createUi() - unknown EAP method");
+ }
+
+ // Load cipher suites view
+ QVariant variant;
+ variant = mEapConfig.value(EapQtConfig::CipherSuites);
+ mGroupItemCs = new CpEapCiphersuiteUi(variant);
+ mModel->appendDataFormItem(mGroupItemCs);
+
+ mItemDataHelper->bindToForm(mForm);
+ mForm->setModel(mModel);
+
+ // Connect signal to add validators
+ bool connected = connect(mForm, SIGNAL( itemShown(const QModelIndex&) ), this,
+ SLOT( setValidator(const QModelIndex) ));
+ Q_ASSERT(connected);
+
+ // Expand TLS based method settings group
+ mForm->setExpanded(mModel->indexFromItem(mGroupItem), true);
+}
+
+/*!
+ * Creates EAP-TLS settings UI
+ */
+void CpEapTlsMethodsUi::createTlsUi()
+{
+ qDebug("CpEapTlsMethodsUi::createTlsUi()");
+ // Create common TLS settings componenets
+ createAuthorityCerts();
+ createUserCerts();
+ createUsername();
+ createRealm();
+}
+
+/*!
+ * Creates EAP-TTLS settings UI
+ */
+void CpEapTlsMethodsUi::createTtlsUi()
+{
+ qDebug("CpEapTlsMethodsUi::createTtlsUi()");
+ // Create common TLS settings componenets
+ createAuthorityCerts();
+ createUserCerts();
+ createUsername();
+ createRealm();
+
+ // Create Inner Eap type selection comboBox and configuration button
+ createInnerMethod();
+}
+
+/*!
+ * Creates PEAP settings UI
+ */
+void CpEapTlsMethodsUi::createPeapUi()
+{
+ qDebug("CpEapTlsMethodsUi::createPeapUi()");
+ // Create common TLS settings componenets
+ createAuthorityCerts();
+ createUserCerts();
+ createUsername();
+ createRealm();
+
+ // Create PEAP version selection comboBox
+ createPeapVersion();
+
+ // Create Inner Eap type selection comboBox and configuration button
+ createInnerMethod();
+
+ // If not stored inner Eap type, set default inner EAP method
+ // according PEAP version
+ if (mDefaultPluginInUse) {
+ defaultInnerPlugin();
+ }
+}
+/*!
+ * Creates Username group:
+ * Generate automatically checkBox and username lineEdit
+ */
+void CpEapTlsMethodsUi::createUsername()
+{
+ qDebug("CpEapTlsMethodsUi::createUsername()");
+ // UsernameAutomatic
+ mUsernameAutomatic = new CpSettingFormItemData(HbDataFormModelItem::CheckBoxItem, hbTrId(
+ "txt_occ_setlabel_user_name"));
+ mUsernameAutomatic->setContentWidgetData("text", hbTrId(
+ "txt_occ_setlabel_user_name_val_generate_automatica"));
+ // Initialize the value from EapQtConfig
+ // Generate username automatically is selected by default
+ mUsernameAutomatic->setContentWidgetData("checkState", boolToCheckState(mEapConfig.value(
+ EapQtConfig::UsernameAutomatic).toBool()));
+ // Connect signal to disable/enable username when usernameAutomatic changed
+ mForm->addConnection(mUsernameAutomatic, SIGNAL(stateChanged(int)), this,
+ SLOT(usernameAutomaticChanged(int)));
+ mGroupItem->appendChild(mUsernameAutomatic);
+
+ //Username
+ mUsername = new CpSettingFormItemData(HbDataFormModelItem::TextItem, hbTrId(
+ "txt_occ_setlabel_user_name"));
+ mUsername->setContentWidgetData("text", mEapConfig.value(EapQtConfig::Username));
+ // Dim username if usernameAutomatic selected
+ usernameAutomaticChanged(mUsernameAutomatic->contentWidgetData("checkState") == Qt::Checked);
+ mGroupItem->appendChild(mUsername);
+}
+
+/*!
+ * Creates Realm group:
+ * Generate automatically checkBox and realm lineEdit
+ */
+void CpEapTlsMethodsUi::createRealm()
+{
+ qDebug("CpEapTlsMethodsUi::createRealm()");
+ // RealmAutomatic
+ mRealmAutomatic = new CpSettingFormItemData(HbDataFormModelItem::CheckBoxItem, hbTrId(
+ "txt_occ_setlabel_realm"));
+ mRealmAutomatic->setContentWidgetData("text", hbTrId(
+ "txt_occ_setlabel_realm_val_generate_automatically"));
+ // Initialize the value from EapQtConfig
+ // Generate realm automatically is selected by default
+ mRealmAutomatic->setContentWidgetData("checkState", boolToCheckState(mEapConfig.value(
+ EapQtConfig::RealmAutomatic).toBool()));
+ // connect signal to disable/enable realm when realmAutomatic changed
+ mForm->addConnection(mRealmAutomatic, SIGNAL(stateChanged(int)), this,
+ SLOT(realmAutomaticChanged(int)));
+ mGroupItem->appendChild(mRealmAutomatic);
+
+ //Realm
+ mRealm = new CpSettingFormItemData(HbDataFormModelItem::TextItem, hbTrId(
+ "txt_occ_setlabel_realm"));
+ mRealm->setContentWidgetData("text", mEapConfig.value(EapQtConfig::Realm));
+ // Dim realm if realmAutomatic selected
+ realmAutomaticChanged(mRealmAutomatic->contentWidgetData("checkState") == Qt::Checked);
+ mGroupItem->appendChild(mRealm);
+}
+
+/*!
+ * Creates User certificate selection comboBox
+ */
+void CpEapTlsMethodsUi::createUserCerts()
+{
+ qDebug("CpEapTlsMethodsUi::createUserCerts()");
+ // Create User certificate comboBox
+ CpSettingFormItemData *userCertList = new CpSettingFormItemData(
+ HbDataFormModelItem::ComboBoxItem,
+ hbTrId("txt_occ_setlabel_user_certificate"));
+
+ // Stored certificate
+ QList<QVariant> storedCertsList = mEapConfig.value(EapQtConfig::UserCertificate).toList();
+ EapQtCertificateInfo storedCert;
+ if (!storedCertsList.empty() && storedCertsList[0].canConvert<EapQtCertificateInfo> ()) {
+ // Stored certificate found, index is still unknown
+ storedCert = storedCertsList[0].value<EapQtCertificateInfo> ();
+ mCurrentUserCert = UnknownIndex;
+ }
+ else {
+ // no stored certificate, use 'not in use'
+ mCurrentUserCert = DefaultIndex;
+ }
+
+ // User certificates found from system
+ mUserCerts = mConfigIf->userCertificates();
+
+ // List of comboBox items
+ QStringList items;
+ // Add 'Not in use' to comboBox list
+ items << hbTrId("txt_occ_setlabel_user_certificate_val_not_in_use");
+ // Add certificates to comboBox list and find index of stored certificate
+ for (int i = 0; i < mUserCerts.count(); ++i) {
+ items << mUserCerts.at(i).value(EapQtCertificateInfo::CertificateLabel).toString();
+ if (mCurrentUserCert == UnknownIndex
+ && storedCert.value(EapQtCertificateInfo::SubjectKeyId)
+ == mUserCerts.at(i).value(EapQtCertificateInfo::SubjectKeyId)) {
+ mCurrentUserCert = i + 1;
+ }
+ }
+ if (mCurrentUserCert == UnknownIndex) {
+ // Stored certificate not found in the certificate list
+ qDebug("CpEapTlsMethodsUi::createUserCerts() - stored certificate not in the list");
+ mCurrentUserCert = DefaultIndex;
+ }
+
+ // Initialize comboBox
+ userCertList->setContentWidgetData("items", items);
+ userCertList->setContentWidgetData("currentIndex", mCurrentUserCert);
+
+ // Get info when user certificate selection has been changed
+ mForm->addConnection(userCertList, SIGNAL(currentIndexChanged(int)), this,
+ SLOT(userCertChanged(int)));
+ mGroupItem->appendChild(userCertList);
+}
+
+/*!
+ * Creates Authority certs group:
+ * Select automatically check box and certificate comboBox
+ */
+void CpEapTlsMethodsUi::createAuthorityCerts()
+{
+ qDebug("CpEapTlsMethodsUi::createAuthorityCerts()");
+ // Select Authority Certificate Automatically
+ mCaCertAutomatic = new CpSettingFormItemData(HbDataFormModelItem::CheckBoxItem, hbTrId(
+ "txt_occ_setlabel_authority_certificate"));
+ mCaCertAutomatic->setContentWidgetData("text", hbTrId(
+ "txt_occ_setlabel_authority_certificate_val_select"));
+ // Initialize the value from EapQtConfig
+ // Select CA Cert automatically is selected by default
+ mCaCertAutomatic->setContentWidgetData("checkState", boolToCheckState(mEapConfig.value(
+ EapQtConfig::AuthorityCertificateAutomatic).toBool()));
+ // connect signal to disable/enable CA cert when CaCertAutomatic changed
+ mForm->addConnection(mCaCertAutomatic, SIGNAL(stateChanged(int)), this,
+ SLOT(authorityCertAutomaticChanged(int)));
+ mGroupItem->appendChild(mCaCertAutomatic);
+
+ // Authority certificate comboBox
+ mCaCert = new CpSettingFormItemData(HbDataFormModelItem::ComboBoxItem,
+ hbTrId("txt_occ_setlabel_authority_certificate"));
+
+ // Stored certificate from EAP configuration
+ QList<QVariant> storedCertsList = mEapConfig.value(EapQtConfig::AuthorityCertificate).toList();
+ EapQtCertificateInfo storedCert;
+ if (!storedCertsList.empty() && storedCertsList[0].canConvert<EapQtCertificateInfo> ()) {
+ // Stored certificate found, index is still unknown
+ storedCert = storedCertsList[0].value<EapQtCertificateInfo> ();
+ mCurrentAuthorityCert = UnknownIndex;
+ }
+ else {
+ // no selected certificate, use 'not in use'
+ mCurrentAuthorityCert = DefaultIndex;
+ }
+
+ // Authority certificates found from system
+ mAuthorityCerts = mConfigIf->certificateAuthorityCertificates();
+
+ // List of comboBox items
+ QStringList items;
+ // Add 'Not in use' to comboBox list
+ items << hbTrId("txt_occ_setlabel_authority_certificate_val_not_in");
+ // Add certificates to comboBox list and find index of stored certificate
+ for (int i = 0; i < mAuthorityCerts.count(); ++i) {
+ items << mAuthorityCerts.at(i).value(EapQtCertificateInfo::CertificateLabel).toString();
+ if (mCurrentAuthorityCert == UnknownIndex
+ && storedCert.value(EapQtCertificateInfo::SubjectKeyId)
+ == mAuthorityCerts.at(i).value(EapQtCertificateInfo::SubjectKeyId)) {
+ mCurrentAuthorityCert = i + 1;
+ }
+ }
+ if (mCurrentAuthorityCert == UnknownIndex) {
+ // Selected certificate not found in the certificate list
+ mCurrentAuthorityCert = DefaultIndex;
+ }
+
+ // Initialize Authority certificates comboBox
+ mCaCert->setContentWidgetData("items", items);
+ mCaCert->setContentWidgetData("currentIndex", mCurrentAuthorityCert);
+
+ // Get info when authority certificate selection has been changed
+ mForm->addConnection(mCaCert, SIGNAL(currentIndexChanged(int)), this,
+ SLOT(authorityCertChanged(int)));
+ // Dim authority certificate if select automatically checked
+ authorityCertAutomaticChanged(mCaCertAutomatic->contentWidgetData("checkState") == Qt::Checked);
+ mGroupItem->appendChild(mCaCert);
+}
+
+/*!
+ * Creates PEAP version selection comboBox
+ */
+void CpEapTlsMethodsUi::createPeapVersion()
+{
+ qDebug("CpEapTlsMethodsUi::createPeapVersion()");
+ // Create PEAP version comboBox
+ mPeapVersion = new CpSettingFormItemData(
+ HbDataFormModelItem::ComboBoxItem,
+ hbTrId("txt_occ_setlabel_peap_version"));
+
+ // Add items to comboBox List
+ QStringList items;
+ items << hbTrId("txt_occ_setlabel_peap_version_val_peapv0")
+ << hbTrId("txt_occ_setlabel_peap_version_val_peapv1")
+ << hbTrId("txt_occ_setlabel_peap_version_val_peapv0_or_peapv1");
+ mPeapVersion->setContentWidgetData("items", items);
+
+ // Initialize PEAP version from EAP configuration
+ if (mEapConfig.value(EapQtConfig::PeapVersion0Allowed).toBool()
+ && mEapConfig.value(EapQtConfig::PeapVersion1Allowed).toBool()) {
+ // PEAPv0 or PEAPv1
+ mCurrentPeapVersion = PeapVersionBoth;
+ }
+ else if (mEapConfig.value(EapQtConfig::PeapVersion1Allowed).toBool()) {
+ // PEAPv1
+ mCurrentPeapVersion = PeapVersion1;
+ }
+ else if (mEapConfig.value(EapQtConfig::PeapVersion0Allowed).toBool()) {
+ // PEAPv0
+ mCurrentPeapVersion = PeapVersion0;
+ }
+ else {
+ qDebug("CpEapTlsMethodsUi::createPeapVersion() - unknown version");
+ // Set default (PEAPv0 or PEAPv1)
+ mCurrentPeapVersion = PeapVersionBoth;
+ }
+ mPeapVersion->setContentWidgetData("currentIndex", mCurrentPeapVersion);
+
+ // Get info when PEAP version selection has been changed
+ mForm->addConnection(mPeapVersion, SIGNAL(currentIndexChanged(int)), this,
+ SLOT(peapVersionChanged(int)));
+ mGroupItem->appendChild(mPeapVersion);
+}
+
+/*!
+ * Creates inner EAP type selection comboBox and configure button
+ */
+void CpEapTlsMethodsUi::createInnerMethod()
+{
+ qDebug("CpEapTlsMethodsUi::createInnerMethod()");
+ // Create inner EAP type selection combo box
+ createEapSelector();
+ // Create 'configure inner EAP type' button
+ EapInnerMethodEntryItemData *eapEntry = NULL;
+ eapEntry = new EapInnerMethodEntryItemData(this, *mItemDataHelper,
+ hbTrId("txt_occ_button_inner_eap_type"));
+ mGroupItem->appendChild(eapEntry);
+}
+
+/*!
+ * Creates Combo box for inner EAP type selection
+ */
+void CpEapTlsMethodsUi::createEapSelector()
+{
+ mInnerEapType = new CpSettingFormItemData(
+ HbDataFormModelItem::ComboBoxItem,
+ hbTrId("txt_occ_setlabel_inner_eap_type"));
+
+ // Selected inner EAP type stored into the database
+ QList<QVariant> currentEapList = mEapConfig.value(EapQtConfig::InnerType).toList();
+ EapQtPluginHandle readInnerEap;
+ if (!currentEapList.empty() && currentEapList[0].canConvert<EapQtPluginHandle> ()) {
+ readInnerEap = currentEapList[0].value<EapQtPluginHandle> ();
+ mCurrentInnerPlugin = UnknownIndex;
+ }
+ else {
+ // no selected inner EAP type, use the first one
+ mCurrentInnerPlugin = DefaultIndex;
+ mDefaultPluginInUse = true;
+ }
+
+ QStringList items;
+ for (int i = 0; i < mPlugins.count(); ++i) {
+ // Add certificate to comboBox list
+ items << mPlugins.at(i).localizationId();
+ if (mCurrentInnerPlugin == UnknownIndex && readInnerEap.pluginId()
+ == mPlugins.at(i).pluginHandle().pluginId()) {
+ // Store index of selected certificate
+ mCurrentInnerPlugin = i;
+ }
+ if (mPlugins.at(i).pluginHandle().pluginId() == EapQtPluginHandle::PluginEapMschapv2) {
+ // Store index of EAP-MSCHAPv2 (used as default with PEAP and unauthenticated FAST)
+ mInnerEapMschapv2 = i;
+ }
+ else if (mPlugins.at(i).pluginHandle().pluginId() == EapQtPluginHandle::PluginEapGtc) {
+ // Store index of EAP-GTC (Used as default with PEAPv1)
+ mInnerEapGtc = i;
+ }
+ }
+ if (mCurrentInnerPlugin == UnknownIndex) {
+ // Selected inner EAP type not found
+ mCurrentInnerPlugin = DefaultIndex;
+ mDefaultPluginInUse = true;
+ }
+
+ mInnerEapType->setContentWidgetData("items", items);
+ mInnerEapType->setContentWidgetData("currentIndex", mCurrentInnerPlugin);
+
+ mForm->addConnection(mInnerEapType, SIGNAL(currentIndexChanged(int)), this,
+ SLOT(innerEapTypeChanged(int)));
+
+ mGroupItem->appendChild(mInnerEapType);
+}
+
+/*!
+ * Adds validators.
+ *
+ * @param modelIndex Model index
+ */
+void CpEapTlsMethodsUi::setValidator(const QModelIndex modelIndex)
+{
+ qDebug("CpEapTlsMethodsUi::itemActivated");
+
+ HbDataFormViewItem *viewItem = qobject_cast<HbDataFormViewItem *>
+ (mForm->itemByIndex(modelIndex));
+ HbDataFormModelItem *modelItem = mModel->itemFromIndex(modelIndex);
+
+ if (modelItem == mUsername) {
+ // When username lineEdit is activated (shown) first time, validator is added
+ mValidatorUsername.reset(mConfigIf->validatorEap(mPluginInfo.pluginHandle().type(),
+ EapQtConfig::Username));
+ HbLineEdit *edit = qobject_cast<HbLineEdit *> (viewItem->dataItemContentWidget());
+ mValidatorUsername->updateEditor(edit);
+ }
+ else if (modelItem == mRealm) {
+ // When realm lineEdit is activated (shown) first time, validator is added
+ mValidatorRealm.reset(mConfigIf->validatorEap(mPluginInfo.pluginHandle().type(),
+ EapQtConfig::Realm));
+ HbLineEdit *edit = qobject_cast<HbLineEdit *> (viewItem->dataItemContentWidget());
+ mValidatorRealm->updateEditor(edit);
+ }
+}
+
+/*!
+ * Sets default Inner EAP method according PEAP version
+ */
+void CpEapTlsMethodsUi::defaultInnerPlugin()
+{
+ qDebug("CpEapTlsMethodsUi::defaultInnerPlugin()");
+ if (mCurrentPeapVersion == PeapVersion1) {
+ mInnerEapType->setContentWidgetData("currentIndex", mInnerEapGtc);
+ mCurrentInnerPlugin = mInnerEapGtc;
+ }
+ else {
+ mInnerEapType->setContentWidgetData("currentIndex", mInnerEapMschapv2);
+ mCurrentInnerPlugin = mInnerEapMschapv2;
+ }
+}
+
+/*!
+ * Stores the index of selected user certificate
+ *
+ * @param value Index of selected certificate.
+ */
+void CpEapTlsMethodsUi::userCertChanged(int value)
+{
+ qDebug("CpEapTlsMethodsUi::userCertChanged()");
+ mCurrentUserCert = value;
+}
+
+/*!
+ * Stores the index of selected authority certificate
+ *
+ * @param value Index of selected certificate.
+ */
+void CpEapTlsMethodsUi::authorityCertChanged(int value)
+{
+ qDebug("CpEapTlsMethodsUi::authorityCertChanged()");
+ mCurrentAuthorityCert = value;
+}
+
+/*!
+ * Stores the index of selected PEAP version
+ *
+ * @param value Index of selected PEAP version.
+ */
+void CpEapTlsMethodsUi::peapVersionChanged(int value)
+{
+ qDebug("CpEapTlsMethodsUi::peapVersionChanged()");
+ mCurrentPeapVersion = value;
+ defaultInnerPlugin();
+}
+
+/*!
+ * Stores the index of selected inner EAP type
+ *
+ * @param value Index of selected ineer EAP type.
+ */
+void CpEapTlsMethodsUi::innerEapTypeChanged(int value)
+{
+ qDebug("CpEapTlsMethodsUi::innerEapTypeChanged()");
+ mCurrentInnerPlugin = value;
+}
+
+/*!
+ * Dims the username if generate username automatically has been selected.
+ *
+ * @param state Tells is generate automatically checked.
+ */
+void CpEapTlsMethodsUi::usernameAutomaticChanged(int state)
+{
+ qDebug("CpEapTlsMethodsUi::usernameAutomaticChanged");
+
+ mUsername->setContentWidgetData("enabled", !checkStateToBool(state));
+}
+
+/*!
+ * Dims the realm if generate realm automatically has been selected.
+ *
+ * @param state Tells is generate automatically checked.
+ */
+void CpEapTlsMethodsUi::realmAutomaticChanged(int state)
+{
+ qDebug("CpEapTlsMethodsUi::realmAutomaticChanged");
+
+ mRealm->setContentWidgetData("enabled", !checkStateToBool(state));
+}
+
+/*!
+ * Dims the authority certificate if select caCert automatically has been selected.
+ *
+ * @param state Tells is select automatically checked.
+ */
+void CpEapTlsMethodsUi::authorityCertAutomaticChanged(int state)
+{
+ qDebug("CpEapTlsMethodsUi::authorityCertAutomaticChanged");
+
+ mCaCert->setContentWidgetData("enabled", !checkStateToBool(state));
+}
+
+/*!
+ * Converts check box state to boolean.
+ *
+ * @param state Check box state
+ *
+ * @return true if Check box is checked, false otherwise.
+ */
+bool CpEapTlsMethodsUi::checkStateToBool(const int state)
+{
+ return (Qt::Unchecked == state ? false : true);
+}
+
+/*!
+ * Converts boolean to check box state.
+ *
+ * @param state Tells is check box checked.
+ *
+ * @return Qt check state
+ */
+int CpEapTlsMethodsUi::boolToCheckState(const bool state)
+{
+ return (false == state ? Qt::Unchecked : Qt::Checked);
+}
+
+/*!
+ * This is called when user is about to exit the view.
+ * Validates configuration and saves settings.
+ * If configuration is not valid prompts question dialog.
+ * If user chooses "OK" leaves without saving.
+ *
+ */
+void CpEapTlsMethodsUi::close()
+{
+ qDebug("CpEapTlsMethodsUi::close");
+
+ // Validate configuration
+ if (validate()) {
+ qDebug("CpEapTlsMethodsUi::close - Validation OK");
+
+ // Store settings
+ if (storeSettings()){
+ qDebug("CpEapTlsMethodsUi::close - Settings stored, close view");
+ // Close view
+ CpBaseSettingView::close();
+ }
+ else {
+ qDebug("CpEapTlsMethodsUi::close - Store settings failed, prompt warning");
+ // Store failed. Show error note to user
+ QScopedPointer<HbMessageBox> infoBox;
+ infoBox.reset(new HbMessageBox(
+ HbMessageBox::MessageTypeWarning));
+ infoBox->setText(hbTrId("txt_occ_info_unable_to_save_setting"));
+ infoBox->clearActions();
+ // Connect 'OK'-button to CpBaseSettingView 'aboutToClose'-signal
+ HbAction *okAction = new HbAction(hbTrId("txt_common_button_ok"));
+ infoBox->addAction(okAction);
+ bool connected = connect(
+ okAction,
+ SIGNAL(triggered()),
+ this,
+ SIGNAL(aboutToClose()));
+ Q_ASSERT(connected);
+ infoBox->open();
+ infoBox.take();
+ }
+ }
+ else {
+ qDebug("CpEapTlsMethodsUi::close - validation failed. Prompt question.");
+
+ // Validate failed. Request user to exit anyway
+ QScopedPointer<HbMessageBox> messageBox;
+ messageBox.reset(new HbMessageBox(
+ HbMessageBox::MessageTypeQuestion));
+ messageBox->setAttribute(Qt::WA_DeleteOnClose);
+ messageBox->setText(hbTrId("txt_occ_info_incomplete_details_return_without_sa"));
+ messageBox->clearActions();
+ // Connect 'YES'-button to CpBaseSettingView 'aboutToClose'-signal
+ HbAction *okAction = new HbAction(hbTrId("txt_common_button_yes"));
+ messageBox->addAction(okAction);
+ bool connected = connect(
+ okAction,
+ SIGNAL(triggered()),
+ this,
+ SIGNAL(aboutToClose()));
+ Q_ASSERT(connected);
+ // Clicking 'NO'-button does nothing
+ HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_no"));
+ messageBox->addAction(cancelAction);
+ messageBox->setTimeout(HbPopup::NoTimeout);
+ messageBox->open();
+ messageBox.take();
+ }
+}
+
+/*!
+ * Validates settings configuration.
+ *
+ * @return true if configuration OK, false otherwise.
+ */
+bool CpEapTlsMethodsUi::validate()
+{
+ qDebug("CpEapTlsMethodsUi::validate()");
+ bool valid = false;
+
+ if (validateUsernameGroup()
+ && validateRealmGroup()
+ && validateAuthorityCertificate()
+ && validateUserCertificate()
+ && validateCiphersuites()) {
+ valid = true;
+ }
+
+ return valid;
+}
+
+/*!
+ * Validates username checkBox and lineEdit group.
+ *
+ * @return true if OK, false otherwise.
+ */
+bool CpEapTlsMethodsUi::validateUsernameGroup()
+{
+ bool status = false;
+ // true if generate automatically is checked or given value is valid
+ if (mUsernameAutomatic->contentWidgetData("checkState") == Qt::Checked
+ || EapQtValidator::StatusOk == mValidatorUsername->validate(
+ mUsername->contentWidgetData("text"))) {
+ status = true;
+ }
+ qDebug("CpEapTlsMethodsUi::validateUsernameGroup() - status: %d", status);
+ return status;
+}
+
+/*!
+ * Validates realm checkBox and lineEdit group.
+ *
+ * @return true if OK, false otherwise.
+ */
+bool CpEapTlsMethodsUi::validateRealmGroup()
+{
+ bool status = false;
+ // true if generate automatically is checked or given value is valid
+ if (mRealmAutomatic->contentWidgetData("checkState") == Qt::Checked
+ || EapQtValidator::StatusOk == mValidatorRealm->validate(
+ mRealm->contentWidgetData("text"))) {
+ status = true;
+ }
+ qDebug("CpEapTlsMethodsUi::validateRealmGroup() - status: %d", status);
+ return status;
+}
+
+/*!
+ * Validates authority certificate checkBox and comboBox group.
+ *
+ * @return true if OK, false otherwise.
+ */
+bool CpEapTlsMethodsUi::validateAuthorityCertificate()
+{
+ bool status = false;
+ //true if select automatically is checked or certificate is selected
+ if (mCaCertAutomatic->contentWidgetData("checkState") == Qt::Checked
+ || mCurrentAuthorityCert > NotInUseIndex) {
+ status = true;
+ }
+ qDebug("CpEapTlsMethodsUi::validateAuthorityCertificate()- status: %d", status);
+ return status;
+}
+
+/*!
+ * Validates user certificate selection.
+ *
+ * @return false if EAP-TLS and no certificate, true otherwise
+ */
+bool CpEapTlsMethodsUi::validateUserCertificate()
+{
+ bool status = true;
+ // false if EAP-TLS and not selected user certificate
+ if (mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginEapTls
+ && mCurrentUserCert == NotInUseIndex) {
+ status = false;
+ }
+ qDebug("CpEapTlsMethodsUi::validateUserCertificate() - status: %d", status);
+ return status;
+}
+
+/*!
+ * Validates cipher suites selection.
+ *
+ * @return false if no cipher suite is selected, true otherwise
+ */
+bool CpEapTlsMethodsUi::validateCiphersuites()
+{
+ bool status = true;
+ QVariant cipherSuites = mGroupItemCs->ciphersuites();
+ QList<QVariant> cipherList = cipherSuites.toList();
+ if (cipherList.count() == 0){
+ status = false;
+ }
+ qDebug("CpEapTlsMethodsUi::validateCiphersuites() - status: %d", status);
+ return status;
+}
+
+/*!
+ * Write PEAP specific values into the EAP configuration
+ *
+ * @param eapConfig
+ */
+void CpEapTlsMethodsUi::setPeapVersion(EapQtConfig &eapConfig)
+{
+ qDebug("CpEapTlsMethodsUi::setPeapVersion()");
+ if (mCurrentPeapVersion == PeapVersion0) {
+ eapConfig.setValue(EapQtConfig::PeapVersion0Allowed, true);
+ eapConfig.setValue(EapQtConfig::PeapVersion1Allowed, false);
+ }
+ else if (mCurrentPeapVersion == PeapVersion1) {
+ eapConfig.setValue(EapQtConfig::PeapVersion0Allowed, false);
+ eapConfig.setValue(EapQtConfig::PeapVersion1Allowed, true);
+ }
+ else {
+ Q_ASSERT(mCurrentPeapVersion == PeapVersionBoth);
+ eapConfig.setValue(EapQtConfig::PeapVersion0Allowed, true);
+ eapConfig.setValue(EapQtConfig::PeapVersion1Allowed, true);
+ }
+}
+
+/*!
+ * Stores settings given via TLS based methods setting UI
+ *
+ * @return false if saving failed, true otherwise
+ */
+bool CpEapTlsMethodsUi::storeSettings()
+{
+ qDebug("CpEapTlsMethodsUi::storeSettings");
+
+ EapQtConfig eapConfig;
+
+ // Store common settings
+ qDebug("CpEapTlsMethodsUi::storeSettings - Common settings");
+ eapConfig.setValue(EapQtConfig::OuterType, qVariantFromValue(mOuterHandle));
+ eapConfig.setValue(EapQtConfig::UsernameAutomatic, checkStateToBool(
+ mUsernameAutomatic->contentWidgetData("checkState").toInt()));
+ eapConfig.setValue(EapQtConfig::Username, mUsername->contentWidgetData("text"));
+ eapConfig.setValue(EapQtConfig::RealmAutomatic, checkStateToBool(
+ mRealmAutomatic->contentWidgetData("checkState").toInt()));
+ eapConfig.setValue(EapQtConfig::Realm, mRealm->contentWidgetData("text"));
+
+ // User certificate
+ qDebug("CpEapTlsMethodsUi::storeSettings - User certificate");
+ if (mCurrentUserCert > NotInUseIndex) {
+ QList<QVariant> userCerts;
+ userCerts.append(qVariantFromValue(mUserCerts.at(mCurrentUserCert - 1)));
+ // The first item in UI(index 0) is 'not in use'
+ eapConfig.setValue(EapQtConfig::UserCertificate, userCerts);
+ }
+
+ // Authority certificate
+ qDebug("CpEapTlsMethodsUi::storeSettings - Authority certificate");
+ eapConfig.setValue(EapQtConfig::AuthorityCertificateAutomatic, checkStateToBool(
+ mCaCertAutomatic->contentWidgetData("checkState").toInt()));
+ if (mCurrentAuthorityCert > NotInUseIndex && !checkStateToBool(
+ mCaCertAutomatic->contentWidgetData("checkState").toInt())) {
+ QList<QVariant> authorityCerts;
+ authorityCerts.append(qVariantFromValue(mAuthorityCerts.at(mCurrentAuthorityCert - 1)));
+ // The first item in UI(index 0) is 'not in use'
+ eapConfig.setValue(EapQtConfig::AuthorityCertificate, authorityCerts);
+ }
+
+ // Inner EAP method (Not valid for EAP-TLS)
+ if (!(mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginEapTls)) {
+ qDebug("CpEapTlsMethodsUi::storeSettings - Inner EAP method");
+ QList<QVariant> innerEaps;
+ innerEaps.append(qVariantFromValue(mPlugins.at(mCurrentInnerPlugin).pluginHandle()));
+ eapConfig.setValue(EapQtConfig::InnerType, innerEaps);
+ }
+
+ // Cipher suites
+ qDebug("CpEapTlsMethodsUi::storeSettings - Cipher suites");
+ eapConfig.setValue(EapQtConfig::CipherSuites, mGroupItemCs->ciphersuites());
+
+ // PEAP version (valid only for PEAP)
+ if (mPluginInfo.pluginHandle() == EapQtPluginHandle::PluginPeap) {
+ setPeapVersion(eapConfig);
+ }
+
+ // Save configuration
+ if (!mConfigIf->saveConfiguration(mPluginInfo.pluginHandle(), eapConfig)) {
+ qDebug("CpEapTlsMethodsUi::storeSettings - configuration saving failed.");
+ return false;
+ }
+ return true;
+}
+