--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/securitydialogs/AutolockSrv/src/AutolockSrv.cpp Mon May 03 13:20:16 2010 +0300
@@ -0,0 +1,1295 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, version 2.1 of the License.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program. If not,
+* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
+*
+* Description:
+*
+*/
+
+// #include "xqservicelog.h"
+
+#include <QApplication>
+#include <QKeyEvent>
+#include <QEvent>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QStackedWidget>
+#include <QImageReader>
+#include <QDebug>
+#include <QTimer>
+#include <QPushButton>
+#include <QLineEdit>
+#include <QListView>
+#include <QMessageBox>
+#include <QToolButton>
+#include <QSymbianEvent>
+#include <QMainWindow>
+#include <qvaluespacesubscriber.h>
+#include <qvaluespacepublisher.h>
+
+QTM_USE_NAMESPACE
+
+#include <HbIndicator>
+#include <hbdevicemessagebox.h>
+
+#include "../../SecUi/inc/SecQueryUi.h"
+
+#include <lockappclientserver.h>
+
+#include <xqsharablefile.h>
+
+#include <QGraphicsLinearLayout>
+
+#include <hblabel.h>
+
+#include "AutolockSrv.h"
+#include <xqserviceutil.h>
+
+#include "autolockuseractivityservice.h"
+
+#include <settingsinternalcrkeys.h> // CenRep keys
+
+#include <W32STD.H>
+#include <eikenv.h>
+
+#include <qapplication.h>
+
+#include <secuisecuritysettings.h>
+#include <secui.h>
+#include <secuisecurityhandler.h>
+#include <etelmm.h>
+#include <rmmcustomapi.h>
+
+#include <qvaluespacesubscriber.h>
+
+#include <hwrmlightdomaincrkeys.h>
+#include <ProfileEngineSDKCRKeys.h>
+#include <e32property.h>
+#include <coreapplicationuisdomainpskeys.h>
+#include "../../../inc/securityuisprivatepskeys.h"
+#include <avkondomainpskeys.h>
+
+#include <hbdevicedialog.h>
+
+const TInt KPhoneIndex( 0 );
+const TInt KTriesToConnectServer( 2 );
+const TInt KTimeBeforeRetryingServerConnection( 50000 );
+
+#define ESecUiTypeLock 0x00100000
+
+_LIT( KMmTsyModuleName, "PhoneTsy");
+
+
+#define XQSERVICE_DEBUG_PRINT(a) qDebug() << (a)
+
+AutolockSrv::AutolockSrv(QWidget *parent, Qt::WFlags f)
+ : QWidget(parent, f),
+ mService(NULL)
+{
+ XQSERVICE_DEBUG_PRINT("AutolockSrv::AutolockSrv");
+ RDEBUG( "start", 0 );
+ mService = new AutolockSrvService(this);
+
+ /* Adjust the palette */
+#if defined(Q_WS_S60)
+ RDEBUG( "Q_WS_S60", 1 );
+ QPalette p = qApp->palette();
+ QColor color(192,192,192);
+ QColor bg(201,250,250);
+ p.setColor(QPalette::Highlight, color.lighter(200));
+ p.setColor(QPalette::Text, Qt::black);
+ p.setColor(QPalette::Base, bg);
+ p.setColor(QPalette::WindowText, Qt::black);
+ p.setColor(QPalette::Window, bg);
+ p.setColor(QPalette::ButtonText, Qt::black);
+ p.setColor(QPalette::Button, color.lighter(150));
+ p.setColor(QPalette::Link, QColor(240,40,40));
+
+ qApp->setPalette(p);
+#endif
+
+ QPushButton *unlockButton = new QPushButton(tr("Unlock"));
+ QPushButton *unguardButton = new QPushButton(tr("Unguard"));
+ QPushButton *lockButton = new QPushButton(tr("Lock"));
+ QPushButton *quitButton = new QPushButton(tr("Quit"));
+ QPushButton *test1Button = new QPushButton(tr("Autolock 10 seconds"));
+ QPushButton *test2Button = new QPushButton(tr("Autolock never"));
+ connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));
+ connect(lockButton, SIGNAL(clicked()), this, SLOT(lockAction()));
+ connect(unlockButton, SIGNAL(clicked()), this, SLOT(unlockAction()));
+ connect(unguardButton, SIGNAL(clicked()), this, SLOT(unguardAction()));
+ connect(test1Button, SIGNAL(clicked()), this, SLOT(test1Action()));
+ connect(test2Button, SIGNAL(clicked()), this, SLOT(test2Action()));
+ RDEBUG( "connect", 1 );
+
+ /* there's no use for this */
+ /*
+ bool isService = XQServiceUtil::isService();
+
+ QString t = "SERVICEAPP:\n";
+ t = t + (isService ? " LAUNCHED AS SERVICE\n" : " LAUNCHED NORMALLY\n");
+ t = t + (XQServiceUtil::isEmbedded() ? " EMBEDDED\n" : " NOT EMBEDDED\n");
+
+ QStringList args = QApplication::arguments();
+ foreach (QString arg, args)
+ {
+ t += "cmdline arg=" + arg + "\n";
+ }
+
+ QLabel *title = new QLabel(t);
+ */
+
+ mLabel = new QLabel("");
+ mNumberEdit = new QLineEdit("");
+
+ QVBoxLayout *vl = new QVBoxLayout;
+
+ vl->setMargin(0);
+ vl->setSpacing(0);
+
+ vl->addWidget(lockButton);
+ vl->addWidget(unlockButton);
+ vl->addWidget(unguardButton);
+ vl->addWidget(quitButton);
+ vl->addWidget(test1Button);
+ vl->addWidget(test2Button);
+ RDEBUG( "added test2Button", 1 );
+
+ mLabelIcon = new QToolButton;
+ mLabelIcon->setIcon(QIcon(":/AutolockSrv_hbicon/qtg_large_device_lock.svg"));
+ mLabelIcon->setIconSize(QSize(300,300));
+
+ vl->addWidget(mLabelIcon);
+ RDEBUG( "added mLabelIcon", 1 );
+
+/* vl->addItem(title);
+ vl->addWidget(mLabel);
+ vl->addWidget(mNumberEdit);
+*/
+ setLayout(vl);
+
+#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+ setFixedSize(QSize(360,640)); // nHD
+#elif defined(Q_WS_S60)
+ // showMaximized();
+ showFullScreen();
+#endif
+ mLabelIcon_visible=1;
+ serviceKeyguard = new AutolockUserActivityService();
+ serviceDevicelock = new AutolockUserActivityService();
+
+ TInt lockValue = 0;
+ TInt lightsTimeout = 0;
+ CRepository* repository;
+ TInt cRresult=0;
+
+ iLockStatusPrev=ELockNotActive;
+ iLockStatus=ELockNotActive;
+ repository = CRepository::NewL(KCRUidSecuritySettings);
+ cRresult = repository->Get(KSettingsAutolockStatus, lockValue);
+ RDEBUG( "KSettingsAutolockStatus", KSettingsAutolockStatus );
+ RDEBUG( "cRresult", cRresult );
+ RDEBUG( "lockValue", lockValue );
+ iLockStatus = lockValue;
+ // the settings says to lock
+ delete repository;
+
+ adjustInactivityTimers(0);
+
+ repository = CRepository::NewL(KCRUidProfileEngine);
+ cRresult = repository->Get(KProEngActiveProfile, lightsTimeout);
+ delete repository;
+
+ repository = CRepository::NewL(KCRUidLightSettings);
+ cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout);
+ delete repository;
+
+ // TODO flip
+
+ subscriberKSettingsAutolockStatus = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutolockStatus", this);
+ connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutolockStatusChanged()));
+ subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutoLockTime", this);
+ connect(subscriberKSettingsAutoLockTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutoLockTimeChanged()));
+ subscriberKSettingsAutomaticKeyguardTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime", this);
+ connect(subscriberKSettingsAutomaticKeyguardTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutomaticKeyguardTimeChanged()));
+ subscriberKDisplayLightsTimeout = new QValueSpaceSubscriber("/KCRUidLightSettings/KDisplayLightsTimeout", this);
+ connect(subscriberKDisplayLightsTimeout, SIGNAL(contentsChanged()), this, SLOT(subscriberKDisplayLightsTimeoutChanged()));
+ subscriberKProEngActiveProfile = new QValueSpaceSubscriber("/KCRUidProfileEngine/KProEngActiveProfile", this);
+ connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this, SLOT(subscriberKProEngActiveProfileChanged()));
+
+
+ TSecurityPolicy readPolicy( ECapabilityReadDeviceData );
+ TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );
+ TInt ret = RProperty::Define( KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy, writePolicy );
+ RDEBUG( "defined KSecurityUIsSecUIOriginatedQuery", ret );
+ ret = RProperty::Define( KPSUidSecurityUIs, KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy, writePolicy );
+ RDEBUG( "defined KSecurityUIsQueryRequestCancel", ret );
+
+ _LIT_SECURITY_POLICY_PASS(KReadPolicy);
+ _LIT_SECURITY_POLICY_C1(KWritePolicy, ECapabilityWriteDeviceData);
+ ret = RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, RProperty::EInt, KReadPolicy, KWritePolicy);
+ RDEBUG( "defined KCoreAppUIsAutolockStatus", ret );
+
+ ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), KWritePolicy);
+ RDEBUG( "defined KAknKeyguardStatus", ret );
+
+ // inactivity
+ connect(serviceKeyguard, SIGNAL(active()), this, SLOT(activeKeyguard()) );
+ connect(serviceKeyguard, SIGNAL(notActive()), this, SLOT(notActiveKeyguard()) );
+ connect(serviceDevicelock, SIGNAL(active()), this, SLOT(activeDevicelock()) );
+ connect(serviceDevicelock, SIGNAL(notActive()), this, SLOT(notActiveDevicelock()) );
+
+ RWindowGroup& groupWin=CEikonEnv::Static()->RootWin();
+ RDEBUG( "got groupWin", 1 );
+ // TODO if I want to release, I should do: mKeyCaptureHandle = env->RootWin().CaptureKey(EKeyBackspace, 0, 0);
+ groupWin.CaptureKey(EKeyBackspace,0,0);
+ groupWin.CaptureKey(EKeyDeviceF,0,0);
+ groupWin.CaptureKey(EKeyBell,0,0);
+ groupWin.CaptureKey(EKeyTab,0,0);
+ groupWin.CaptureKey(EKeyInsert,0,0);
+ RDEBUG( "got mKeyCaptureHandle", 1 );
+
+ iSecQueryUiCreated=-1;
+ iDeviceDialogCreated = -1;
+ // TODO for now, always starts unlocked
+ // TryChangeStatus(iLockStatus);
+ TryChangeStatus(ELockNotActive);
+ lower();
+ hide();
+ // not needed: new AutolockSrvService(this);
+}
+
+
+AutolockSrv::~AutolockSrv()
+{
+ RDEBUG( "0", 0 );
+ delete mService;
+}
+
+void AutolockSrv::adjustInactivityTimers(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+ TInt keyguardTime = 0;
+ TInt lockTime = 0;
+ CRepository* repository;
+ TInt cRresult = 0;
+
+ repository = CRepository::NewL(KCRUidSecuritySettings);
+ cRresult = repository->Get(KSettingsAutoLockTime, lockTime);
+ RDEBUG( "KSettingsAutoLockTime", KSettingsAutoLockTime );
+ RDEBUG( "cRresult", cRresult );
+ RDEBUG( "lockTime", lockTime );
+ if(lockTime>0 && lockTime<1000)
+ {
+ serviceDevicelock->setInactivityPeriod(lockTime);
+ }
+ else
+ {
+ serviceDevicelock->setInactivityPeriod(12*31*24*60*60);
+ }
+
+ cRresult = repository->Get(KSettingsAutomaticKeyguardTime, keyguardTime);
+ RDEBUG( "KSettingsAutomaticKeyguardTime", KSettingsAutomaticKeyguardTime );
+ RDEBUG( "cRresult", cRresult );
+ RDEBUG( "keyguardTime", keyguardTime );
+ if(keyguardTime>0 && keyguardTime<1000)
+ {
+ serviceKeyguard->setInactivityPeriod(keyguardTime);
+ }
+ else
+ {
+ serviceKeyguard->setInactivityPeriod(12*31*24*60*60);
+ }
+ delete repository;
+}
+void AutolockSrv::quit()
+{
+ RDEBUG( "0", 0 );
+ qApp->quit();
+}
+
+// from the button
+void AutolockSrv::unlockAction()
+{
+ RDEBUG( "0", 0 );
+ TryChangeStatus(ELockAppDisableDevicelock);
+}
+
+void AutolockSrv::unguardAction()
+{
+ RDEBUG( "0", 0 );
+ TryChangeStatus(ELockAppDisableKeyguard);
+}
+
+void AutolockSrv::test1Action()
+{
+ RDEBUG( "Set(KSettingsAutoLockTime, 30000)", 30000 );
+
+ CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);
+ repositorySet->Set(KSettingsAutoLockTime, 10);
+ delete repositorySet;
+}
+
+void AutolockSrv::test2Action()
+{
+ RDEBUG( "Set(KSettingsAutoLockTime, 20000)", 20000 );
+
+ CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);
+ repositorySet->Set(KSettingsAutoLockTime, 0);
+ delete repositorySet;
+}
+
+int AutolockSrv::AskValidSecCode(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+RMobilePhone iPhone; // NULL in emulator
+
+#ifdef __WINS__1
+return KErrNone;
+#endif
+
+TInt err( KErrGeneral);
+TBool validCode(EFalse);
+TInt thisTry( 0);
+RTelServer iTelServer;
+
+RMmCustomAPI iCustomPhone;
+while ( ( err = iTelServer.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer )
+ {
+ User::After( KTimeBeforeRetryingServerConnection );
+ }
+err = iTelServer.LoadPhoneModule( KMmTsyModuleName );
+RTelServer::TPhoneInfo PhoneInfo;
+ RDEBUG( "err", err );
+err = iTelServer.SetExtendedErrorGranularity( RTelServer::EErrorExtended ) ;
+ RDEBUG( "err", err );
+err = iTelServer.GetPhoneInfo( KPhoneIndex, PhoneInfo ) ;
+ RDEBUG( "err", err );
+err = iPhone.Open( iTelServer, PhoneInfo.iName ) ;
+ RDEBUG( "err", err );
+err = iCustomPhone.Open( iPhone ) ;
+ RDEBUG( "err", err );
+
+ RDEBUG( "CSecurityHandler", 0 );
+CSecurityHandler* handler = new(ELeave) CSecurityHandler(iPhone);
+if(aReason==ELockAppDisableDevicelock)
+ {
+ RDEBUG( "calling AskSecCodeInAutoLockL", 0 );
+ validCode = handler->AskSecCodeInAutoLockL(); // this returns true/false
+ // TODO should this also do iPhone.SetLockSetting(status, lockType, lockChange); ???
+ }
+else if(aReason==ELockAppEnableDevicelock)
+ {
+ // check whether code is really needed
+ RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);
+ RMobilePhone::TMobilePhoneLockSetting lockChange(RMobilePhone::ELockSetDisabled);
+ TRequestStatus status = KRequestPending;
+ TInt ret=KErrNone;
+ RDEBUG( "GetLockInfo", 0 );
+ iPhone.GetLockInfo(status, lockType, lockInfoPkg);
+ RDEBUG( "WaitForRequest", 0 );
+ User::WaitForRequest( status );
+ ret = status.Int();
+ RDEBUG( "WaitForRequest ret", ret );
+ #ifdef __WINS__
+ if(ret==KErrTimedOut)
+ {
+ ret = KErrNone;
+ lockInfo.iSetting = RMobilePhone::ELockSetDisabled; // ask password only if there's no timeout.
+ }
+ #endif
+ if(ret==KErrNone)
+ {
+ RDEBUG( "lockInfo.iSetting", lockInfo.iSetting );
+ RDEBUG( "RMobilePhone::ELockSetDisabled", RMobilePhone::ELockSetDisabled );
+ if(lockInfo.iSetting == RMobilePhone::ELockSetDisabled) // ask password only if there's no timeout
+ {
+ lockChange = RMobilePhone::ELockSetEnabled;
+ RDEBUG( "SetLockSetting lockChange", lockChange );
+ #define OLD_METHODx
+ #ifdef OLD_METHOD
+ status = KRequestPending;
+ RDEBUG( "SetLockSetting", 0 );
+ iPhone.SetLockSetting(status, lockType, lockChange); // ask for PassPhraseRequiredL
+ RDEBUG( "WaitForRequestL", 0 );
+ User::WaitForRequest( status ); // TODO this waits 33 seconds in WINS and returns ffffffdf = KErrTimedOut
+ ret = status.Int();
+ RDEBUG( "WaitForRequestL ret", ret );
+ #else
+ RDEBUG( "! OLD_METHOD", 0 );
+ CWait *iWait = NULL;
+ iWait = CWait::NewL();
+ iWait->SetRequestType(EMobilePhoneSetLockSetting);
+ iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange); // ask for PassPhraseRequiredL
+ RDEBUG( "WaitForRequestL", 0 );
+ ret = iWait->WaitForRequestL();
+ RDEBUG( "WaitForRequestL ret", ret );
+ if(iWait)
+ {
+ RDEBUG( "IsActive", 0 );
+ if(iWait->IsActive())
+ {
+ RDEBUG( "CancelAsyncRequest", 0 );
+ iPhone.CancelAsyncRequest(iWait->GetRequestType());
+ RDEBUG( "cancelled", 0 );
+ }
+ }
+ delete iWait;
+ #endif
+
+ RDEBUG( "WaitForRequestL ret", ret );
+ #ifdef __WINS__
+ if(ret==KErrTimedOut)
+ ret = KErrNone;
+ #endif
+ if(ret==KErrNone)
+ validCode = 1;
+ else
+ validCode = 0;
+ }
+ else
+ validCode = 0x20;
+ }
+ else
+ validCode = 0x21;
+
+ /* Alternative way to ask for password
+ RMobilePhone::TMobilePhoneSecurityEvent iEvent;
+ TInt result = KErrNone;
+ iEvent = RMobilePhone::EPhonePasswordRequired;
+ RDEBUG( "calling HandleEventL", 0 );
+ handler->HandleEventL(iEvent, result); // this is supposed to wait
+ validCode = false;
+ if(result)
+ validCode = true;
+ RDEBUG( "result", result );
+ */
+ }
+// TODO this doesn't wait on WINS , so how do I get the Acceptation?
+ RDEBUG( "validCode (true/false)", validCode );
+if(validCode)
+ return KErrNone;
+return KErrCancel;
+}
+
+void AutolockSrv::lockAction()
+{
+ RDEBUG( "0", 0 );
+
+ XQSERVICE_DEBUG_PRINT("AutolockSrv::lockAction");
+ TryChangeStatus(ELockAppOfferDevicelock);
+
+}
+
+void AutolockSrv::handleAnswerDelivered()
+{
+ RDEBUG( "This should never be called", 0 );
+ // quit();
+
+}
+
+
+void AutolockSrv::endCall()
+{
+ RDEBUG( "This should never be called", 0 );
+ //QVBoxLayout *vl = qobject_cast<QVBoxLayout *>(layout()) ;
+ //vl->removeWidget(mEndCallButton);
+
+ //XQServiceUtil::toBackground(true);
+}
+
+void AutolockSrv::setLabelNumber(QString label,QString number)
+{
+ RDEBUG( "0", 0 );
+ mLabel->setText("mLabel=" + label);
+ mNumberEdit->setText("mNumberEdit=" + number);
+}
+
+void AutolockSrv::DebugRequest(int aReason)
+{
+ switch(aReason)
+ {
+ case ELockAppEnableKeyguard:
+ RDEBUG( "ELockAppEnableKeyguard", aReason );
+ break;
+ case ELockAppDisableKeyguard:
+ RDEBUG( "ELockAppDisableKeyguard", aReason );
+ break;
+ case ELockAppEnableDevicelock:
+ RDEBUG( "ELockAppEnableDevicelock", aReason );
+ break;
+ case ELockAppDisableDevicelock:
+ RDEBUG( "ELockAppDisableDevicelock", aReason );
+ break;
+ case ELockAppOfferKeyguard:
+ RDEBUG( "ELockAppOfferKeyguard", aReason );
+ break;
+ case ELockAppOfferDevicelock:
+ RDEBUG( "ELockAppOfferDevicelock", aReason );
+ break;
+ case ELockAppShowKeysLockedNote:
+ RDEBUG( "ELockAppShowKeysLockedNote", aReason );
+ break;
+ default:
+ RDEBUG( "default", aReason );
+ break;
+ }
+}
+void AutolockSrv::DebugStatus(int aReason)
+{
+ switch(aReason)
+ {
+ case ELockNotActive:
+ RDEBUG( "ELockNotActive", aReason );
+ break;
+ case EKeyguardActive:
+ RDEBUG( "EKeyguardActive", aReason );
+ break;
+ case EDevicelockActive:
+ RDEBUG( "EDevicelockActive", aReason );
+ break;
+ default:
+ RDEBUG( "default", aReason );
+ break;
+ }
+}
+void AutolockSrv::DebugError(int aReason)
+{
+ switch(aReason)
+ {
+ case KErrPermissionDenied:
+ RDEBUG( "KErrPermissionDenied", aReason );
+ break;
+ case KErrNone:
+ RDEBUG( "KErrNone", aReason );
+ break;
+ case KErrAlreadyExists:
+ RDEBUG( "KErrAlreadyExists", aReason );
+ break;
+ default:
+ RDEBUG( "default", aReason );
+ break;
+ }
+}
+
+int AutolockSrv::CheckIfLegal(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+ switch ( aReason )
+ {
+ case ELockAppEnableKeyguard:
+ {
+ RDEBUG( "ELockAppEnableKeyguard iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ if ( 1==0 ) // !CKeyLockPolicyApi::KeyguardAllowed() )
+ return KErrPermissionDenied;
+ else
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrAlreadyExists;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppDisableKeyguard:
+ {
+ RDEBUG( "ELockAppDisableKeyguard iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrAlreadyExists;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppEnableDevicelock:
+ {
+ RDEBUG( "ELockAppEnableDevicelock iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrAlreadyExists;
+ }
+ }
+ break;
+ case ELockAppDisableDevicelock:
+ {
+ RDEBUG( "ELockAppDisableDevicelock iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrAlreadyExists;
+ case EKeyguardActive:
+ return KErrPermissionDenied;
+ case EDevicelockActive:
+ return KErrNone;
+ }
+ }
+ break;
+ case ELockAppOfferKeyguard:
+ {
+ RDEBUG( "ELockAppOfferKeyguard iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrPermissionDenied;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppOfferDevicelock:
+ {
+ RDEBUG( "ELockAppOfferDevicelock iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrAlreadyExists;
+ }
+ }
+ break;
+ case ELockAppShowKeysLockedNote:
+ {
+ RDEBUG( "ELockAppShowKeysLockedNote iLockStatus", iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrPermissionDenied;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ default:
+ {
+ RDEBUG( "default iLockStatus", iLockStatus );
+ return KErrPermissionDenied;
+ }
+ // break;
+ } // switch
+ return KErrPermissionDenied;
+}
+
+int AutolockSrv::publishStatus(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+const TUid KCRUidCoreApplicationUIsSysAp = { 0x101F8765 };
+const TUint32 KSysApKeyguardActive = 0x00000001;
+CRepository* repositoryDevicelock;
+CRepository* repositoryKeyguard;
+repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings);
+repositoryKeyguard = CRepository::NewL(KCRUidSecuritySettings);
+TInt cRresult;
+
+ if(1==1)
+ {
+ RDEBUG( "publishing", aReason );
+ if(aReason==ELockNotActive)
+ {
+ RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardNotActive);
+ RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
+ // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0); // the settings remains. Only ISA changes, as well as the P&S
+ cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0);
+ }
+ if(1==0)
+ {
+ if(aReason==EKeyguardActive)
+ {
+ RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardLocked);
+ RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
+ // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0);
+ cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 1);
+ }
+ else if(aReason>=EDevicelockActive)
+ {
+ RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardNotActive); // EKeyguardLocked sure? maybe EKeyguardNotActive ?
+ RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EManualLocked);
+ // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 1);
+ cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0); // keyguard disabled, so that user can type and DeviceF can be captured
+ }
+ }
+ }
+delete repositoryDevicelock;
+delete repositoryKeyguard;
+// this is the real point where everything is done.
+iLockStatusPrev = iLockStatus;
+iLockStatus = aReason;
+ RDEBUG( "setting iLockStatus", iLockStatus );
+return KErrNone;
+}
+/********************/
+int AutolockSrv::showNoteIfRequested(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+
+ if(aReason==ELockNotActive)
+ {
+ if(iShowKeyguardNote==1)
+ {
+ HbDeviceMessageBox::information ("Keyguard deactivated");
+ }
+ }
+ else if(aReason==EKeyguardActive)
+ {
+ if(iShowKeyguardNote==1)
+ {
+ HbDeviceMessageBox::information ("Keyguard activated");
+ }
+ }
+ else if(aReason>=EDevicelockActive) // this doesn't happen, but we are prepared nevertheless
+ {
+ if(iShowKeyguardNote==1)
+ {
+ HbDeviceMessageBox::information ("Devicelock activated");
+ }
+ }
+return KErrNone;
+}
+/***********************/
+int AutolockSrv::TryChangeStatus(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+ int ret = aReason;
+ int errorInProcess = KErrNone;
+ DebugRequest(ret);
+
+ switch(ret)
+ {
+ case ELockAppEnableKeyguard: // 1
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ if(errorInProcess==KErrNone)
+ {
+ setLabelIcon(EKeyguardActive);
+ updateIndicator(EKeyguardActive);
+ publishStatus(EKeyguardActive);
+ showNoteIfRequested(EKeyguardActive);
+ }
+ }
+ break;
+ case ELockAppDisableKeyguard: // 2
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ if(errorInProcess==KErrNone)
+ {
+ setLabelIcon(ELockNotActive);
+ updateIndicator(ELockNotActive);
+ publishStatus(ELockNotActive);
+ showNoteIfRequested(ELockNotActive);
+ }
+ }
+ break;
+ case ELockAppEnableDevicelock: // 3
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ if(errorInProcess==KErrNone)
+ {
+ if(!callerHasECapabilityWriteDeviceData) // check permissions for calling process, because doesn't AskValidSecCode
+ errorInProcess=KErrPermissionDenied;
+ DebugError(errorInProcess);
+ }
+ if(errorInProcess==KErrNone)
+ {
+ updateIndicator(EDevicelockActive);
+ publishStatus(EDevicelockActive);
+ setLabelIcon(EDevicelockActive);
+ setLockDialog(aReason, 1);
+ }
+ // aParam1 is aReason : EDevicelockManual, EDevicelockRemote
+ // this never shows a note
+ }
+ break;
+ case ELockAppDisableDevicelock: // 4
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ if(errorInProcess==KErrNone)
+ {
+ if(!callerHasECapabilityWriteDeviceData) // check permissions for calling process, because doesn't AskValidSecCode
+ errorInProcess=KErrPermissionDenied;
+ DebugError(errorInProcess);
+ }
+ if(errorInProcess==KErrNone)
+ {
+ RDEBUG( " calling HbDeviceMessageBox::question", 0 );
+ bool value = HbDeviceMessageBox::question("Disable Lock?");
+ RDEBUG( "value", value );
+ if(!value)
+ errorInProcess = KErrCancel;
+ }
+ if(errorInProcess==KErrNone)
+ {
+ setLockDialog(aReason, 0); // hide temporarilly because AskValidSecCode doesn't get in top of the Lock-icon. Thus, dismiss it.
+ RDEBUG( "calling AskValidSecCode", 0 );
+ errorInProcess=AskValidSecCode(ELockAppDisableDevicelock);
+ RDEBUG( "errorInProcess", errorInProcess );
+ }
+ if(errorInProcess==KErrNone)
+ {
+ setLabelIcon(ELockNotActive);
+ updateIndicator(ELockNotActive);
+ publishStatus(ELockNotActive);
+ }
+ if(errorInProcess!=KErrNone)
+ { // re-lock. For example, if password is wrong
+ setLockDialog(aReason, 1);
+ }
+ // this never shows a note
+ }
+ break;
+ case ELockAppOfferKeyguard: // 5
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ if(errorInProcess==KErrNone)
+ {
+ bool value = HbDeviceMessageBox::question("Enable Keyguard?");
+ // TODO what about a nice icon?
+ RDEBUG( "value", value );
+ if(!value)
+ errorInProcess = KErrCancel;
+ }
+ if(errorInProcess==KErrNone)
+ {
+ errorInProcess = TryChangeStatus(ELockAppEnableKeyguard);
+ }
+ // this never shows a note
+ }
+ break;
+ case ELockAppOfferDevicelock: // 6
+ {
+ errorInProcess = CheckIfLegal(ret);
+ DebugError(errorInProcess);
+ setLockDialog(aReason, 0); // hide temporarilly because AskValidSecCode doesn't get in top of the Lock-icon. Thus, dismiss it.
+ errorInProcess=AskValidSecCode(ELockAppEnableDevicelock);
+ if(errorInProcess==KErrNone)
+ {
+ errorInProcess = TryChangeStatus(ELockAppEnableDevicelock);
+ }
+ // this never shows a note. Perhaps ELockAppEnableDevicelock does.
+ }
+ break;
+ case ELockAppShowKeysLockedNote:
+ {
+ iShowKeyguardNote=1; // this is not sent as parameter, so we need to fake it: ON
+ showNoteIfRequested(EKeyguardActive);
+ }
+ break;
+ default:
+ RDEBUG( "default", ret );
+ errorInProcess = KErrNotSupported;
+ break;
+
+ }
+ return errorInProcess;
+}
+/**************************/
+int AutolockSrv::setLockDialog(int aReason, int status)
+{
+ RDEBUG( "aReason", aReason );
+ RDEBUG( "status", status );
+ RDEBUG( "iDeviceDialogCreated", iDeviceDialogCreated );
+ if(status==0) // hide
+ {
+ if(iDeviceDialogCreated>0)
+ {
+ iDeviceDialogCreated = 0;
+ iDeviceDialog->cancel();
+ }
+ }
+ else if(status==1) // show
+ {
+ QVariantMap params;
+ TBool err;
+ #define ESecUiTypeDeviceLock 0x00100000
+ #define ESecUiTypeKeyguard 0x00200000
+
+ if(aReason==EKeyguardActive)
+ params.insert("type", ESecUiTypeKeyguard);
+ else if(aReason>=EDevicelockActive)
+ params.insert("type", ESecUiTypeDeviceLock);
+ else
+ {
+ RDEBUG( "error. status=1 but aReason", aReason );
+ }
+ // no need for title. Icon should be explicit enough
+ // params.insert("title", "Locked");
+ if(iDeviceDialogCreated<=0)
+ {
+ RDEBUG( "creating iDeviceDialog", 0 );
+ iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);
+ iDeviceDialogCreated = 1;
+ }
+ else
+ {
+ RDEBUG( "raising iDeviceDialog", 0 );
+ // confirm that dialog is present
+ err = iDeviceDialog->error();
+ RDEBUG( "err", err );
+ iDeviceDialogCreated = 2;
+ }
+ const QString KSecQueryUiDeviceDialog("com.nokia.secuinotificationdialog/1.0");
+ RDEBUG( "pre show", aReason );
+ err = iDeviceDialog->show( KSecQueryUiDeviceDialog, params );
+ RDEBUG( "post show. err", err );
+ err = iDeviceDialog->error();
+ RDEBUG( "err", err );
+ }
+ else
+ {
+ RDEBUG( "unknown status", status );
+ return KErrNotSupported;
+ }
+return KErrNone;
+}
+void AutolockSrv::setLabelIcon(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+
+ if(aReason==ELockNotActive)
+ {
+ mLabelIcon->setVisible(false);
+ setLockDialog(aReason, 0); // TODO isn't this done already at TryChangeStatus ???
+ lower();
+ hide();
+ }
+ else if(aReason==EKeyguardActive)
+ {
+ mLabelIcon->setVisible(true);
+ setLockDialog(aReason, 1);
+ raise(); // not repaint(), not show() , not setVisible(true), not showFullScreen() , not ???
+ show();
+ }
+ else if(aReason==EDevicelockActive)
+ {
+ mLabelIcon->setVisible(true);
+ raise();
+ show();
+ }
+ else
+ {
+ RDEBUG( "error: aReason", aReason );
+ }
+}
+
+int AutolockSrv::updateIndicator(int aReason)
+{
+ RDEBUG( "aReason", aReason );
+ QList<QVariant> list;
+ list.insert(0, 1);
+ list.insert(1, "aaa");
+ list.insert(2, 2);
+
+ HbIndicator indicator;
+ bool success;
+ if(aReason==ELockNotActive)
+ success = indicator.deactivate("com.nokia.hb.indicator.autolocksrv.autolocksrv_8/1.0"); // maybe it's already deactivated. Not a problem
+ else if(aReason==EKeyguardActive)
+ success = indicator.activate("com.nokia.hb.indicator.autolocksrv.autolocksrv_8/1.0");
+ else if(aReason==EDevicelockActive)
+ success = indicator.activate("com.nokia.hb.indicator.autolocksrv.autolocksrv_8/1.0"); // same. We have just 1 indicator
+ else
+ success = 0;
+ RDEBUG( "success", success );
+ return success;
+}
+
+void AutolockSrv::activeKeyguard()
+{
+ // activity while keyguarded. Nothing to do
+ RDEBUG( "0", 0 );
+}
+
+void AutolockSrv::notActiveKeyguard()
+{
+ // inactivity. Keyguard should be activated
+ RDEBUG( "0", 0 );
+ int ret = 0;
+ DebugStatus(iLockStatus);
+ if(iLockStatus==ELockNotActive) // not possible if it's keyguarded, or locked
+ {
+ ret = TryChangeStatus(ELockAppEnableKeyguard);
+ }
+}
+
+void AutolockSrv::activeDevicelock()
+{
+ RDEBUG( "0", 0 );
+}
+
+void AutolockSrv::notActiveDevicelock()
+{
+ // inactivity. Devicelock should be activated
+ RDEBUG( "0", 0 );
+ int ret = 0;
+ DebugStatus(iLockStatus);
+ if(iLockStatus==ELockNotActive || iLockStatus==EKeyguardActive ) // not possible if it's locked
+ {
+ ret = TryChangeStatus(ELockAppEnableDevicelock);
+ }
+}
+
+// some key is pressed
+bool AutolockSrv::event(QEvent *ev)
+{
+ if (ev)
+ {
+ int isSwitchKey=0;
+ // on device, this doesn't seem to get the EKeyDeviceF key: only 1ffffff
+ if (ev->type() == QEvent::KeyPress){
+ QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
+ qDebug() << QString("KeyPress:%1\n").arg(keyEvent->key(), 0, 16) ;
+ qDebug() << keyEvent->key();
+ qDebug() << EKeyInsert;
+ qDebug() << (keyEvent->key()&0xFF);
+ qDebug() << (EKeyInsert&0xFF);
+ if((keyEvent->key()&0xFF) == (EKeyInsert&0xFF))
+ {
+ qDebug() << "pressed EKeyInsert";
+ // only reacts on release, not on press
+ isSwitchKey=1;
+ }
+ if((keyEvent->key()&0xFF) == (EKeyTab&0xFF))
+ {
+ qDebug() << "pressed EKeyTab";
+ }
+ if((keyEvent->key()&0xFF) == (EKeyDeviceF&0xFF))
+ {
+ qDebug() << "pressed EKeyDeviceF";
+ }
+ if( keyEvent->key() ==0x1ffffff )
+ {
+ qDebug() << "pressed EKeyDeviceF-1ffffff";
+ isSwitchKey=1;
+ }
+ }
+ else if (ev->type() == QEvent::KeyRelease)
+ {
+ QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
+ qDebug() << QString("KeyRelease:%1\n").arg(keyEvent->key(), 0, 16) ;
+ if( keyEvent->key() ==0x1ffffff )
+ {
+ RDEBUG( "released EKeyDeviceF-1ffffff", 1 );
+ // isSwitchKey=1; this should happen is pressed was not processed (hint: if it is/was in background)
+ }
+ }
+ RDEBUG( "isSwitchKey", isSwitchKey );
+ if(isSwitchKey)
+ {
+ int ret;
+ DebugStatus(iLockStatus);
+ if(iLockStatus==ELockNotActive)
+ {
+ iShowKeyguardNote = 1; // note on enable keyguard
+ ret = TryChangeStatus(ELockAppEnableKeyguard); // this should not ask confirmation
+ }
+ else if(iLockStatus==EKeyguardActive)
+ {
+ iShowKeyguardNote = 1; // note on disable keyguard
+ ret = TryChangeStatus(ELockAppDisableKeyguard);
+ }
+ else if(iLockStatus==EDevicelockActive)
+ {
+ ret = TryChangeStatus(ELockAppDisableDevicelock);
+ }
+ } // isSwitchKey
+ } // ev
+ // Process if not done before. For example, redraw or quit
+ return QWidget::event(ev);
+}
+
+bool AutolockSrv::eventFilter(QObject *o, QEvent *ev)
+{
+ // this never happens
+ RDEBUG( "0", 0 );
+ return QWidget::eventFilter(o, ev);
+
+}
+
+void AutolockSrv::subscriberKSettingsAutolockStatusChanged()
+ {
+ RDEBUG( "0", 0 );
+ QVariant v = subscriberKSettingsAutolockStatus->value("/KCRUidSecuritySettings/KSettingsAutolockStatus");
+ adjustInactivityTimers(KSettingsAutolockStatus);
+ qDebug() << "AutolockSrv::subscriberKSettingsAutolockStatusChanged" << v;
+ }
+void AutolockSrv::subscriberKSettingsAutoLockTimeChanged()
+ {
+ RDEBUG( "0", 0 );
+ QVariant v = subscriberKSettingsAutoLockTime->value("/KCRUidSecuritySettings/KSettingsAutoLockTime");
+ adjustInactivityTimers(KSettingsAutoLockTime);
+ qDebug() << "AutolockSrv::subscriberKSettingsAutoLockTimeChanged" << v;
+ }
+void AutolockSrv::subscriberKSettingsAutomaticKeyguardTimeChanged()
+ {
+ RDEBUG( "0", 0 );
+ QVariant v = subscriberKSettingsAutomaticKeyguardTime->value("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime");
+ adjustInactivityTimers(KSettingsAutoLockTime);
+ qDebug() << "AutolockSrv::subscriberKSettingsAutomaticKeyguardTimeChanged" << v;
+ }
+void AutolockSrv::subscriberKDisplayLightsTimeoutChanged()
+ {
+ RDEBUG( "0", 0 );
+ QVariant v = subscriberKDisplayLightsTimeout->value("/KCRUidLightSettings/KDisplayLightsTimeout");
+ // nothing to do
+ qDebug() << "AutolockSrv::subscriberKDisplayLightsTimeoutChanged" << v;
+ }
+void AutolockSrv::subscriberKProEngActiveProfileChanged()
+ {
+ RDEBUG( "0", 0 );
+ QVariant v = subscriberKProEngActiveProfile->value("/KCRUidProfileEngine/KProEngActiveProfile");
+ // nothing to do
+ qDebug() << "AutolockSrv::subscriberKProEngActiveProfileChanged" << v;
+ }
+
+// ----------AutolockSrvService---------------
+
+AutolockSrvService::AutolockSrvService(AutolockSrv* parent)
+: XQServiceProvider(QLatin1String("com.nokia.services.AutolockSrv.AutolockSrv"),parent),
+ mAutolockSrv(parent),
+ mAsyncReqId(-1),
+ mAsyncAnswer(false)
+{
+ RDEBUG( "0", 0 );
+ publishAll();
+ connect(this, SIGNAL(returnValueDelivered()), parent, SLOT(handleAnswerDelivered()));
+}
+
+AutolockSrvService::~AutolockSrvService()
+{
+ RDEBUG( "0", 0 );
+}
+
+void AutolockSrvService::complete(QString number)
+{
+ RDEBUG( "0", 0 );
+ if (mAsyncReqId == -1)
+ return;
+ XQSERVICE_DEBUG_PRINT("AutolockSrvService::complete");
+ completeRequest(mAsyncReqId,number.toInt());
+}
+
+// gor API request
+int AutolockSrvService::service(const QString& number, const QString& aParam1, const QString& aParam2 )
+{
+ RDEBUG( "0", 0 );
+ qDebug() << "number=" << number;
+ qDebug() << "aParam1=" << aParam1;
+ qDebug() << "aParam2=" << aParam2;
+ mAsyncAnswer = false;
+ XQRequestInfo info = requestInfo();
+ QSet<int> caps = info.clientCapabilities();
+
+ mAutolockSrv->callerHasECapabilityWriteDeviceData=0;
+ if(caps.contains(ECapabilityWriteDeviceData))
+ {
+ RDEBUG( "callerHasECapabilityWriteDeviceData", ECapabilityWriteDeviceData );
+ mAutolockSrv->callerHasECapabilityWriteDeviceData=1;
+ }
+
+ QString label = "AutolockSrv::service:\n";
+ label += QString("number=%1\n").arg(number);
+
+ mNumber = number ;
+ mAutolockSrv->setLabelNumber(label, number);
+ int ret = 0;
+ ret = number.toInt();
+
+ mAutolockSrv->mParam1 = aParam1.toInt();
+ mAutolockSrv->iShowKeyguardNote = aParam1.toInt();
+ mAutolockSrv->mParam2 = aParam2.toInt();
+ ret = mAutolockSrv->TryChangeStatus(ret);
+ RDEBUG( "ret", ret );
+ return ret;
+}
+
+void AutolockSrvService::handleClientDisconnect()
+{
+ RDEBUG( "0", 0 );
+ // Just quit service application if client ends
+ mAsyncAnswer = false;
+ RDEBUG( "0", 0 );
+ // mAutolockSrv->quit();
+}
+
+/****************/
+CWait* CWait::NewL()
+ {
+ CWait* self = new(ELeave) CWait();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+void CWait::ConstructL()
+ {
+ CActiveScheduler::Add(this);
+ }
+CWait::CWait() : CActive(0)
+ {
+ }
+CWait::~CWait()
+ {
+ Cancel();
+ }
+TInt CWait::WaitForRequestL()
+ {
+ SetActive();
+ iWait.Start();
+ return iStatus.Int();
+ }
+void CWait::RunL()
+ {
+ if(iWait.IsStarted())
+ iWait.AsyncStop();
+ }
+void CWait::DoCancel()
+ {
+ if(iWait.IsStarted())
+ iWait.AsyncStop();
+ }
+void CWait::SetRequestType(TInt aRequestType)
+{
+ iRequestType = aRequestType;
+}
+TInt CWait::GetRequestType()
+{
+ return iRequestType;
+}
+