diff -r 63339781d179 -r 09b1ac925e3f securitydialogs/secuinotifications/secuinotificationdialogplugin/src/secuinotificationdialog.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/securitydialogs/secuinotifications/secuinotificationdialogplugin/src/secuinotificationdialog.cpp Tue Aug 31 16:04:40 2010 +0300 @@ -0,0 +1,877 @@ +/* +* 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: SecUi notification plugin class. +* +*/ + +#include "secuinotificationdebug.h" +#include "secuinotificationdialog.h" +#include "secuinotificationdialogpluginkeys.h" +#include "secuinotificationcontentwidget.h" +// #include // HbPopupBase::NoTimeout +#include +#include +#include +#include +#include +#include +#include // for TARM error codes while validating new lock code +#include +#include +#include +#include + +QTM_USE_NAMESPACE + +const QString KTranslationsPath = "/resource/qt/translations/"; +const QString KSecUiNotificationTranslationsFile = "secui"; +const QString KCommonTranslationsFile = "common"; + +#include +#include +#define ESecUiBasicTypeText 0x0000000 +#define ESecUiBasicTypeCheck 0x0010000 +#define ESecUiBasicTypeCheckMulti 0x0020000 +#define ESecUiBasicTypeMask 0x00F0000 + +#define ESecUiCancelSupported 0x1000000 +#define ESecUiCancelNotSupported 0x0000000 + +#define ESecUiEmergencySupported 0x2000000 +#define ESecUiEmergencyNotSupported 0x0000000 + +#define ESecUiAlphaSupported 0x4000000 +#define ESecUiAlphaNotSupported 0x0000000 + +#define ESecUiSecretSupported 0x8000000 +#define ESecUiSecretNotSupported 0x0000000 + +#define ESecUiMaskFlags 0xFF000000 +#define ESecUiMaskType 0x00FFFFFF + +#define ESecUiTypeDeviceLock 0x00100000 +#define ESecUiTypeKeyguard 0x00200000 +#define ESecUiTypeClock 0x00300000 +#define ESecUiTypeScreensaver 0x00400000 + +#define ESecUiTypeMaskLock 0x00F00000 + +const TUid KPSUidSecurityUIs = { 0x100059b5 }; +const TUint32 KSecurityUIsDismissDialog = 0x00000309; + +enum TSecurityUIsDismissDialogValues + { + ESecurityUIsDismissDialogUninitialized = 0, + ESecurityUIsDismissDialogOn, + ESecurityUIsDismissDialogProcessing, + ESecurityUIsDismissDialogDone, + ESecurityUIsDismissDialogLastValue + }; + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::SecUiNotificationDialog() +// ---------------------------------------------------------------------------- +// +SecUiNotificationDialog::SecUiNotificationDialog( + const QVariantMap ¶meters) : HbDialog(), mCommonTranslator(0), mSecUiNotificationTranslator(0), mLastError(KNoError) +{ + RDEBUG("0", 0); + TTime myTime; + myTime.HomeTime(); + mMyId = I64LOW( myTime.Int64() ); + mCommonTranslator = new HbTranslator(KTranslationsPath, KCommonTranslationsFile); + mSecUiNotificationTranslator = new HbTranslator(KTranslationsPath, KSecUiNotificationTranslationsFile); + constructDialog(parameters); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::~SecUiNotificationDialog() +// ---------------------------------------------------------------------------- +// +SecUiNotificationDialog::~SecUiNotificationDialog() +{ + RDEBUG("0", 0); + delete mSecUiNotificationTranslator; + delete mCommonTranslator; + RDEBUG("0", 0); + // TODO what about subscriberKSecurityUIsDismissDialog + // and codeTop + RDEBUG("1", 1); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::setDeviceDialogParameters() +// ---------------------------------------------------------------------------- +// +bool SecUiNotificationDialog::setDeviceDialogParameters(const QVariantMap ¶meters) +{ + RDEBUG("0", 0); + return constructDialog(parameters); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::deviceDialogError() +// ---------------------------------------------------------------------------- +// +int SecUiNotificationDialog::deviceDialogError() const +{ + RDEBUG("mLastError", mLastError); + RDEBUG("mMyId", mMyId); + return mLastError; +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::closeDeviceDialog +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::closeDeviceDialog(bool byClient) +{ + Q_UNUSED(byClient); + RDEBUG("mMyId", mMyId); + RDEBUG("calling close()", 0); + close(); + RDEBUG("mShowEventReceived", mShowEventReceived); + + // If show event has been received, close is signalled from hide event. + // If not, hide event does not come and close is signalled from here. + if (!mShowEventReceived) { + RDEBUG("emitting deviceDialogClosed", 0); + emit deviceDialogClosed(); + if(1==0 && subscriberKSecurityUIsDismissDialog) + { + RDEBUG("disconnect subscriberKSecurityUIsDismissDialog", 0); + disconnect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged())); + RDEBUG("disconnected subscriberKSecurityUIsDismissDialog", 1); + if(1==1) + { + RDEBUG("deleting subscriberKSecurityUIsDismissDialog", 0); + delete subscriberKSecurityUIsDismissDialog; + subscriberKSecurityUIsDismissDialog = NULL; + RDEBUG("deleted subscriberKSecurityUIsDismissDialog", 1); + } + } + } + RDEBUG("0", 0); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::deviceDialogWidget +// ---------------------------------------------------------------------------- +// +HbDialog *SecUiNotificationDialog::deviceDialogWidget() const +{ + return const_cast(this); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::hideEvent +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::hideEvent(QHideEvent *event) +{ + RDEBUG("0", 0); + HbDialog::hideEvent(event); + RDEBUG("mMyId", mMyId); + RDEBUG("calling close()", 0); + close(); + RDEBUG("emitting deviceDialogClosed", 0); + emit deviceDialogClosed(); + RDEBUG("deviceDialogClosed", 1); + if(1==0 && subscriberKSecurityUIsDismissDialog) + { + RDEBUG("disconnect subscriberKSecurityUIsDismissDialog", 0); + disconnect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged())); + RDEBUG("disconnected subscriberKSecurityUIsDismissDialog", 1); + if(1==1) + { + RDEBUG("deleting subscriberKSecurityUIsDismissDialog", 0); + delete subscriberKSecurityUIsDismissDialog; + subscriberKSecurityUIsDismissDialog = NULL; + RDEBUG("deleted subscriberKSecurityUIsDismissDialog", 1); + } + } + // old method was emit deviceDialogClosed(); + RDEBUG("0", 0); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::showEvent +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::showEvent(QShowEvent *event) +{ + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + HbDialog::showEvent(event); + + if(!(queryType & ESecUiTypeMaskLock)) + { // not for the "lock icon" + RDEBUG("check default.1", 0); + if(codeTop!=NULL) + { + RDEBUG("check default.2", 0); + if(codeTop->text().length()>0) // there's a default value. Verify it and (might) enable OK + { + RDEBUG("check default.3", 0); + handleCodeTopChanged(codeTop->text()); + } + RDEBUG("setFocus", 0); + // remove setFocus from PIN query because Orbit can't handle it + // codeTop->setFocus(); // this should open the VKB . Doesn't seem to work when it's done on the widget, so it's done here. + } // codeTop!=NULL + + const TUint32 KSecurityUIsTestCode = 0x00000307; + TInt value = 0; + TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsTestCode, value ); + RDEBUG("KSecurityUIsTestCode err", err); + RDEBUG("faking value", value); + RDEBUG("mShowEventReceived", mShowEventReceived); + if(value>0 && value<1000000 && mShowEventReceived==true) // show happens 2 times. Dialog can be closed only the second. + { + QString myString = ""; + myString += QString("%1").arg(value); + RDEBUGQT("myString", myString); + codeTop->setText( myString ); + TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsTestCode, 0 ); // clear after using it + RDEBUGQT("calling handleAccepted myString", myString); + emit handleAccepted(); + // handleAccepted already emit closeDeviceDialog(false); // false means "not by client", although it's not really used + } + } + mShowEventReceived = true; + RDEBUG("1", 1); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::constructDialog() +// ---------------------------------------------------------------------------- +// +bool SecUiNotificationDialog::constructDialog(const QVariantMap ¶meters) + { + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + setTimeout(HbPopup::NoTimeout); + setDismissPolicy(HbPopup::NoDismiss); + setModal(true); + mShowEventReceived = false; + subscriberKSecurityUIsDismissDialog = NULL; + titleWidget = NULL; + RDEBUG("subscriberKSecurityUIsDismissDialog NULL", 0); + + subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this); + if(subscriberKSecurityUIsDismissDialog) + { + RDEBUG("subscriberKSecurityUIsDismissDialog created", 1); + } + else + { + RDEBUG("subscriberKSecurityUIsDismissDialog not created", 0); + } + connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged())); + RDEBUG("subscriberKSecurityUIsDismissDialog", 1); + + // Title + // this is also done later in the widget + // For now, it only says "Security" + if (parameters.contains(KDialogTitle)) { + QString titleText = parameters.value(KDialogTitle).toString(); + QString titleAttempts = ""; + if(titleText.indexOf('|')>0) + { // if separator, take only first part + titleText = titleText.left(titleText.indexOf('|')); + } + if(titleText.indexOf('$')>0) + { // if separator, take only first part + titleAttempts = titleText.right(titleText.length()-titleText.indexOf('$')-1); + RDEBUGQT("titleAttempts", titleAttempts); + int nAttempts = titleAttempts.toInt(); + RDEBUG("nAttempts", nAttempts); + titleText = titleText.left(titleText.indexOf('$')); + if(nAttempts>0) + titleText = titleText + " attempts=" + QString::number(nAttempts); + } + titleText = hbTrId("Security Query"); // this is the header, for any potential later error which needs to be displayed + // This is created only if needed (i.e. errors for NewLockCode) + // titleWidget = new HbLabel(titleText); + // setHeadingWidget(titleWidget); + } + + if (parameters.contains(KEmergency)) { + RDEBUG("KEmergency", 1); + QString emergencyText = parameters.value(KEmergency).toString(); + RDEBUGQT("emergencyText", emergencyText); + if(!emergencyText.compare("emergencyYes")) + { + RDEBUG("emergencyYes", 1); + isEmergency = 1; + okAction->setEnabled(true); + okAction->setText(hbTrId("Call")); + return true; + } + if(!emergencyText.compare("emergencyNo")) + { + RDEBUG("emergencyNo", 1); + isEmergency = 0; + okAction->setEnabled(false); // 112 -> 1122 (=password) . This is handled by < lMinLength + okAction->setText(hbTrId("Ok")); + return true; + } + } + // after TARM validation. + if (parameters.contains(KInvalidNewLockCode)) { + RDEBUG("KInvalidNewLockCode", 0); + QString invalidText = parameters.value(KInvalidNewLockCode).toString(); + RDEBUGQT("invalidText", invalidText); + QString newTitleText = "Lock Code"; // TODO take from the original one + + QString invalidStr = invalidText.right(invalidText.length()-invalidText.indexOf('$')-1); + int invalidNumber = invalidStr.toInt(); + RDEBUG("invalidNumber", invalidNumber); + if(invalidNumber<0) // that is, -1 + { + RDEBUG("invalidNumber<0", invalidNumber ); + // nothing to do + } + if(invalidNumber==EDeviceLockAutolockperiod) + { + RDEBUG("EDeviceLockAutolockperiod", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockAutolockperiod"); + } + if(invalidNumber==EDeviceLockMaxAutolockPeriod) + { + RDEBUG("EDeviceLockAutolockperiod", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMaxAutolockPeriod"); + } + if(invalidNumber==EDeviceLockMinlength) + { + RDEBUG("EDeviceLockMinlength", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMinlength"); + } + if(invalidNumber==EDeviceLockMaxlength) + { + RDEBUG("EDeviceLockMaxlength", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMaxlength"); + } + if(invalidNumber==EDeviceLockRequireUpperAndLower) + { + RDEBUG("EDeviceLockRequireUpperAndLower", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockRequireUpperAndLower"); + } + if(invalidNumber==EDeviceLockRequireCharsAndNumbers) + { + RDEBUG("EDeviceLockMaxlength", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMaxlength"); + } + if(invalidNumber==EDeviceLockAllowedMaxRepeatedChars) + { + RDEBUG("EDeviceLockAllowedMaxRepeatedChars", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockAllowedMaxRepeatedChars"); + } + if(invalidNumber==EDeviceLockHistoryBuffer) + { + RDEBUG("EDeviceLockHistoryBuffer", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockHistoryBuffer"); + } + if(invalidNumber==EDeviceLockPasscodeExpiration) + { + RDEBUG("EDeviceLockPasscodeExpiration", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockPasscodeExpiration"); + } + if(invalidNumber==EDeviceLockMinChangeTolerance) + { + RDEBUG("EDeviceLockMinChangeTolerance", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMinChangeTolerance"); + } + if(invalidNumber==EDeviceLockMinChangeInterval) + { + RDEBUG("EDeviceLockMinChangeInterval", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMinChangeInterval"); + } + if(invalidNumber==EDeviceLockDisallowSpecificStrings) + { + RDEBUG("EDeviceLockDisallowSpecificStrings", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockDisallowSpecificStrings"); + } + if(invalidNumber==EDeviceLockAllowedMaxAtempts) + { + RDEBUG("EDeviceLockAllowedMaxAtempts", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockAllowedMaxAtempts"); + } + if(invalidNumber==EDeviceLockConsecutiveNumbers) + { + RDEBUG("EDeviceLockConsecutiveNumbers", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockConsecutiveNumbers"); + } + if(invalidNumber==EDeviceLockMinSpecialCharacters) + { + RDEBUG("EDeviceLockMinSpecialCharacters", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockMinSpecialCharacters"); + } + if(invalidNumber==EDeviceLockSingleCharRepeatNotAllowed) + { + RDEBUG("EDeviceLockSingleCharRepeatNotAllowed", invalidNumber ); + newTitleText+=hbTrId("EDeviceLockSingleCharRepeatNotAllowed"); + } + if(invalidNumber==EDevicelockConsecutiveCharsNotAllowed) + { + RDEBUG("EDevicelockConsecutiveCharsNotAllowed", invalidNumber ); + newTitleText+=hbTrId("EDevicelockConsecutiveCharsNotAllowed"); + } + if(invalidNumber>=EDevicelockTotalPolicies) + { + RDEBUG("EDevicelockTotalPolicies", invalidNumber ); + newTitleText+=hbTrId("EDevicelockTotalPolicies"); + } + if( !titleWidget ) + { + RDEBUG("creating titleWidget", 0 ); + titleWidget = new HbLabel(hbTrId("New lock code")); // it will be changed later + setHeadingWidget(titleWidget); + } + RDEBUG("setPlainText", 0 ); + titleWidget->setPlainText(newTitleText); + + if(invalidNumber<0) // everything is ok + { + okAction->setEnabled(true); // this might fail in the scenario: check this : invalid -> valid. This allows verif ? + okAction->setText(hbTrId("Ok")); + codeBottom->setEnabled(true); + } + else + { + okAction->setEnabled(false); + codeBottom->setEnabled(false); + codeBottom->setText(""); + okAction->setText(hbTrId("Ok")); + } + // need to return because all objects are already created + return true; + } + + // Content + SecUiNotificationContentWidget *content = new SecUiNotificationContentWidget(); + content->constructFromParameters(parameters); + setContentWidget(content); + + queryType = content->queryType; + queryDual = content->queryDual; + isEmergency = content->isEmergency; + codeTop=NULL; + codeTop = content->codeTop; + checkBox = content->checkbox; + listWidget = content->listWidget; + codeBottom = content->codeBottom; + lMinLength = content->lMinLength; + lMaxLength = content->lMaxLength; + lEmergencySupported = content->lEmergencySupported; + + connect(content, SIGNAL(codeTopChanged(const QString &)), this, SLOT(handleCodeTopChanged(const QString &))); + connect(content, SIGNAL(codeBottomChanged(const QString &)), this, SLOT(handleCodeBottomChanged(const QString &))); + connect(content, SIGNAL(codeTopContentChanged()), this, SLOT(handleCodeTopContentChanged())); + connect(content, SIGNAL(but1Changed()), this, SLOT(handlebut1Changed())); + connect(content, SIGNAL(but2Changed()), this, SLOT(handlebut2Changed())); + connect(content, SIGNAL(but3Changed()), this, SLOT(handlebut3Changed())); + RDEBUG("queryType", queryType); + // Buttons + if( (queryType & ESecUiTypeMaskLock)) + { + // no need to create OK or Cancel + return true; + } + + okAction = new HbAction(hbTrId("Ok")); + RDEBUG("created HbAction okAction", 1); + okAction->setEnabled(false); // initially the OK is disabled because codeTop is empty + if((queryType & ESecUiBasicTypeMask) ==ESecUiBasicTypeCheck) { + okAction->setEnabled(true); + setHeadingWidget(0); // had to remove this no multiline + } + else if ((queryType & ESecUiBasicTypeMask) ==ESecUiBasicTypeCheckMulti){ + okAction->setEnabled(true); + } + + // setAction(okAction, QDialogButtonBox::AcceptRole); // it's supposed to use this, when deprecated + // setPrimaryAction(okAction); + addAction(okAction); + disconnect(okAction, SIGNAL(triggered()), this, SLOT(close())); // the close will be done in handleAccepted + connect(okAction, SIGNAL(triggered()), this, SLOT(handleAccepted())); + + cancelAction = new HbAction(hbTrId("Cancel")); // qtTrId("txt_common_button_cancel") + addAction(cancelAction); + disconnect(cancelAction, SIGNAL(triggered()), this, SLOT(close())); // the close will be done in handleCancelled + connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleCancelled())); + // setAction(cancelAction, QDialogButtonBox::RejectRole); // it's supposed to use this, when deprecated + // setSecondaryAction(cancelAction); + + // this should had been set by Autolock, but just to be sure + TInt ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsDismissDialog, + RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), + TSecurityPolicy(TSecurityPolicy::EAlwaysPass)); + RDEBUG("defined KSecurityUIsDismissDialog", ret); + TInt aDismissDialog = -1; + ret = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsDismissDialog, aDismissDialog ); + RDEBUG("ret", ret); + RDEBUG("aDismissDialog", aDismissDialog); + if(aDismissDialog==ESecurityUIsDismissDialogOn || aDismissDialog==ESecurityUIsDismissDialogProcessing) + { + RDebug::Printf( "potential error: %s %s (%u) aDismissDialog=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aDismissDialog ); + } + + RDEBUG("check cancel", 0); + if ((queryType & ESecUiCancelSupported)==ESecUiCancelSupported) + { + // nothing to do. Cancel is enabled by default + } + else + { + RDEBUG("disable Cancel", 1); + cancelAction->setEnabled(false); + cancelAction->setText(""); + cancelAction->setVisible(false); + } + + return true; +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::sendResult() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::sendResult(int accepted) +{ + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + QVariant acceptedValue(accepted); + RDEBUG("0", 0); + mResultMap.insert(KResultAccepted, acceptedValue); + RDEBUG("0", 0); + RDEBUGQT("mResultMap", mResultMap); + RDEBUG("queryType", queryType); + if(!(queryType & ESecUiTypeMaskLock)) + { // the lock-icon should not reply + RDEBUG("emit deviceDialogData", 0); + emit deviceDialogData(mResultMap); + } + RDEBUG("1", 1); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handleAccepted() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handleAccepted() +{ + RDEBUG("0", 0); + // okAction + RDEBUG("mMyId", mMyId); + QString codeTopText=""; + + if( (queryType & ESecUiTypeMaskLock)) + { + codeTopText = "Unlock-Request"; + } + else if( (queryType & ESecUiBasicTypeMask)==ESecUiBasicTypeCheck) + { + codeTopText=(checkBox->isChecked() ? "1":"0"); + mResultMap.insert(KCodeTopIndex, codeTopText); + } + else if( (queryType & ESecUiBasicTypeMask)==ESecUiBasicTypeCheckMulti) + { + QItemSelectionModel *selectionModel = listWidget->selectionModel(); + QModelIndexList selectedItems = selectionModel->selectedIndexes(); + QModelIndex index; + codeTopText=""; + foreach(index, selectedItems) { + codeTopText+=QString::number(index.row()); + // could also use if(index.row()!=selectedItems.count()-1) codeTopText+= "|"; + codeTopText+= "|"; + } + mResultMap.insert(KCodeTopIndex, codeTopText); + } + else + codeTopText = codeTop->text(); + // no need to check last time for codeBottom + RDEBUGQT("codeTopText", codeTopText); + sendResult(KErrNone); + RDEBUG("calling close()", 0); + close(); // this is needed because Cancel doesn't automatically closes the dialog + RDEBUG("emitting deviceDialogClosed", 0); + emit deviceDialogClosed(); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handleCancelled() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handleCancelled() +{ + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + sendResult(KErrCancel); + RDEBUG("callingclose()", 0); + close(); // this is needed because Cancel doesn't automatically closes the dialog + RDEBUG("emitting deviceDialogClosed", 0); + emit deviceDialogClosed(); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handleMemorySelectionChanged() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handleMemorySelectionChanged(const QString &text) + { + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + RDEBUGQT("text", text); + QVariant memorySelection(text); + mResultMap.insert(KSelectedMemoryIndex, memorySelection); + } + +void SecUiNotificationDialog::handleCodeTopContentChanged() + { + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + RDEBUGQT("codeTop->text()", codeTop->text()); + handleCodeTopChanged(codeTop->text()); + } + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handleCodeTopChanged() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handleCodeTopChanged(const QString &text) + { + RDEBUG("0", 0); + RDEBUGQT("text", text); + if(queryDual) + { + codeBottom->setText(""); // any change resets the verification. + if( (queryType & ESecUiMaskType) == 0x000004 ) // new codeLock + { // ChangeSecCodeParamsL change RMobilePhone::ESecurityCodePhonePassword + QVariant codeTopVar(text); + mResultMap.insert(KCodeTopIndex, codeTopVar); + sendResult(KErrCompletion); // send the current password back to the client for further TARM validation. This is done on any key-press, not in the OK + } + } + else if(text.length() < lMinLength ) + { + RDEBUGQT("too short text", text); + okAction->setEnabled(false); + RDEBUG("lEmergencySupported", lEmergencySupported); + if( lEmergencySupported && text.length() > 2 ) // emergency numbers need at least 3 digits + { // check whether it's a emergency number + QVariant codeTopVar(text); + mResultMap.insert(KCodeTopIndex, codeTopVar); + sendResult(KErrAbort); // send the current password back to the client. Perhaps it's an emergency number and decides to Ok->Call + } + } + else if (text.length() >= lMinLength) + { + // might use a flag to avoid re-setting. But this complicates things if there's another initial verification + RDEBUGQT("long enough text", text); + okAction->setText(hbTrId("Ok")); + if(queryDual==0) // only if Bottom is not used + okAction->setEnabled(true); + } + QVariant codeTopVar(text); + mResultMap.insert(KCodeTopIndex, codeTopVar); + } +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handleCodeBottomChanged() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handleCodeBottomChanged(const QString &text) + { + RDEBUG("0", 0); + RDEBUGQT("text", text); + RDEBUGQT("codeTop->text()", codeTop->text()); + if(text.length() < lMinLength ) + { + RDEBUGQT("too short text", text); + okAction->setEnabled(false); + } + else + { + // might use a flag to avoid re-setting. But it just complicates things. + RDEBUGQT("long enough text", text); + if(codeTop->text()==text) + { + // unless both codes match, don't allow OK. Note that the first field doesn't allow exit until the validations (i.e. NewLockCode) as succesfull + RDEBUGQT("codes match", text); + okAction->setEnabled(true); + } + else + { + RDEBUGQT("codes don't match", text); + okAction->setEnabled(false); + } + } + // verification is not sent + } +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handlebut1Changed() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handlebut1Changed() + { + RDEBUG("0", 0); + codeTop->setText("1234"); + } +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handlebut2Changed() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handlebut2Changed() + { + RDEBUG("0", 0); + QString codeTopText = codeTop->text(); + RDEBUGQT("codeTopText", codeTopText); + codeTopText = codeTopText + "1" ; + RDEBUGQT("codeTopText+1", codeTopText); + codeTop->setText(codeTopText); + + RDEBUG("editorInterface", 0); + HbEditorInterface editorInterface(codeTop); + RDEBUG("actions", 0); + QList vkbList = editorInterface.actions(); + RDEBUG("count", 0); + int count = vkbList.count(); + RDEBUG("got count", count); + for (int i = 0; i < count; i++) + { + RDEBUG("i", i); + HbAction *action = static_cast(vkbList[i]); + RDEBUG("action", 0); + } + + RDEBUG("okVKBAction", 0); + okVKBAction = new HbAction(tr("Ok")); + RDEBUG("addAction", 0); + editorInterface.addAction(okVKBAction); + RDEBUG("addAction", 1); + connect(okVKBAction, SIGNAL(triggered()), this, SLOT(handleAccepted())); + RDEBUG("connect", 1); + + QList vkbList2 = editorInterface.actions(); + RDEBUG("count", 0); + int count2 = vkbList2.count(); + RDEBUG("got count2", count2); + for (int i = 0; i < count2; i++) + { + RDEBUG("i", i); + HbAction *action2 = static_cast(vkbList2[i]); + RDEBUG("action2", 0); + } + + } +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::handlebut3Changed() +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::handlebut3Changed() + { + RDEBUG("0", 0); + QString codeTopText = codeTop->text(); + RDEBUG("codeTopText", 0); + RDEBUGQT("codeTopText", codeTopText); + codeTopText = codeTopText + "5" ; + RDEBUGQT("codeTopText+5", codeTopText); + codeTop->setEchoMode(HbLineEdit::PasswordEchoOnEdit); + RDEBUGQT("codeTopText", codeTopText); + codeTop->setText(codeTopText); + RDEBUG("setFocus", 0); + codeTop->setFocus(); + RDEBUG("1", 1); + } + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::saveFocusWidget(QWidget*,QWidget*) +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::saveFocusWidget(QWidget*,QWidget*) +{ + RDEBUG("0", 0); +} + +// ---------------------------------------------------------------------------- +// SecUiNotificationDialog::subscriberKSecurityUIsDismissDialogChanged() +// A way for Autolock to dismiss any possible PIN dialog +// This doesn't dismiss the lockIcon because P&S is not connected +// Note: if this changes itself, then it becomes recursive +// ---------------------------------------------------------------------------- +// +void SecUiNotificationDialog::subscriberKSecurityUIsDismissDialogChanged() + { + + RDEBUG("0", 0); + RDEBUG("mMyId", mMyId); + TInt aDismissDialog = ESecurityUIsDismissDialogUninitialized; + TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsDismissDialog, aDismissDialog ); + RDEBUG("err", err); + RDEBUG("aDismissDialog", aDismissDialog); + if( aDismissDialog == ESecurityUIsDismissDialogOn ) + { + if(subscriberKSecurityUIsDismissDialog) + { + RDEBUG("subscriberKSecurityUIsDismissDialog", 1); + } + else + { + RDEBUG("! subscriberKSecurityUIsDismissDialog", 0); + } + + if(this) + { + RDEBUG("this", 1); + } + else + { + RDEBUG("! this", 0); + } + + + RDEBUG("disconnect subscriberKSecurityUIsDismissDialog", 0); + disconnect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged())); + // this doesn't really disconnect, because somehow the events are still queued. This is a QtMobility error + RDEBUG("disconnected subscriberKSecurityUIsDismissDialog", 1); + + RDEBUG("not set KSecurityUIsDismissDialog", ESecurityUIsDismissDialogProcessing); + // can't set it because it does recursion + // err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogProcessing ); + RDEBUG("err", err); + // only if Cancel is allowed + if ((queryType & ESecUiCancelSupported)==ESecUiCancelSupported) + { + RDEBUG("sendResult(KErrCancel)", KErrCancel); // another option is KErrDied + sendResult(KErrCancel); // similar to emit handleCancelled(); + RDEBUG("calling close()", 0); + err = close(); + RDEBUG("err", err); + RDEBUG("emitting deviceDialogClosed", 0); + emit deviceDialogClosed(); + // RDEBUG("emit closeDeviceDialog", 0); + // this is old method emit closeDeviceDialog(false); // false means "not by client", although it's not really used + RDEBUG("all emited", 0); + } + RDEBUG("not set KSecurityUIsDismissDialog", ESecurityUIsDismissDialogDone); + // can't set it because it does recursion + // err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogDone ); // clear after using it + RDEBUG("err", err); + + RDEBUG("reconnect subscriberKSecurityUIsDismissDialog", 0); + connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged())); + RDEBUG("reconnected subscriberKSecurityUIsDismissDialog", 1); + } + RDEBUG("1", 1); + }