FCL/sf/mw/securitysrv: comparison securitydialogs/AutolockSrv/src/AutolockSrv.cpp

equal deleted inserted replaced

-:098e361762d2
+:6b63ca65093a
 #include <QEvent>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QStackedWidget>
 #include <QImageReader>
-#include <QDebug>
 #include <QTimer>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QListView>
 #include <QMessageBox>
 #include <xqserviceutil.h>
 #include "autolockuseractivityservice.h"
 #include <settingsinternalcrkeys.h>		// CenRep keys
-#include <W32STD.H>
+#include <w32std.h>
 #include <eikenv.h>
 #include <qapplication.h>
 #include <secuisecuritysettings.h>
 #include <ProfileEngineSDKCRKeys.h>
 #include <e32property.h>
 #include <coreapplicationuisdomainpskeys.h>
 #include "../../../inc/securityuisprivatepskeys.h"
 #include <avkondomainpskeys.h>
+#include <hwrmdomainpskeys.h>
 #include <hbdevicedialog.h>
 const TInt KPhoneIndex(0);
 const TInt KTriesToConnectServer(2);
 #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 autolocksrv", 0);
-RDEBUG("start", 0);
 mService = new AutolockSrvService(this);
 /* Adjust the palette */
 #if defined(Q_WS_S60)
 RDEBUG( "Q_WS_S60", 1 );
 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"));
+QPushButton *test3Button = new QPushButton(tr("SecUiTest"));
 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()));
+connect(test3Button, SIGNAL(clicked()), this, SLOT(test3Action()));
 RDEBUG("connect", 1);
 /* there's no use for this */
 /*
 bool isService = XQServiceUtil::isService();
 vl->addWidget(unlockButton);
 vl->addWidget(unguardButton);
 vl->addWidget(quitButton);
 vl->addWidget(test1Button);
 vl->addWidget(test2Button);
-RDEBUG("added test2Button", 1);
+vl->addWidget(test3Button);
+RDEBUG("added test3Button", 1);
 mLabelIcon = new QToolButton;
 mLabelIcon->setIcon(QIcon(
 ":/AutolockSrv_hbicon/qtg_large_device_lock.svg"));
 mLabelIcon->setIconSize(QSize(300, 300));
 serviceKeyguard = new AutolockUserActivityService();
 serviceDevicelock = new AutolockUserActivityService();
 TInt lockValue = 0;
 TInt lightsTimeout = 0;
-CRepository* repository;
+CRepository* repository = NULL;
 TInt cRresult = 0;
 iLockStatusPrev = ELockNotActive;
 iLockStatus = ELockNotActive;
-repository = CRepository::NewL(KCRUidSecuritySettings);
+QT_TRAP_THROWING( 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);
+QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidProfileEngine) );
 cRresult = repository->Get(KProEngActiveProfile, lightsTimeout);
+// this value is not used for now
 delete repository;
-repository = CRepository::NewL(KCRUidLightSettings);
+QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidLightSettings) );
 cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout);
+// this value is not used for now
 delete repository;
-// TODO flip
+// subscribe to settings changes
 subscriberKSettingsAutolockStatus = new QValueSpaceSubscriber(
 "/KCRUidSecuritySettings/KSettingsAutolockStatus", this);
 connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()),
 this, SLOT(subscriberKSettingsAutolockStatusChanged()));
 subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber(
 subscriberKProEngActiveProfile = new QValueSpaceSubscriber(
 "/KCRUidProfileEngine/KProEngActiveProfile", this);
 connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this,
 SLOT(subscriberKProEngActiveProfileChanged()));
+// subscribe to environment changes
+subscriberKHWRMGripStatus = new QValueSpaceSubscriber(
+"/KPSUidHWRM/KHWRMGripStatus", this);
+connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this,
+SLOT(subscriberKHWRMGripStatusChanged()));
+subscriberKAknKeyguardStatus = new QValueSpaceSubscriber(
+"/KPSUidAvkonDomain/KAknKeyguardStatus", this);
+connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this,
+SLOT(subscriberKAknKeyguardStatusChanged()));
+subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber(
+"/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus", this);
+connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this,
+SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));
+		/////////////
 TSecurityPolicy readPolicy(ECapabilityReadDeviceData);
 TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);
 TInt ret = RProperty::Define(KPSUidSecurityUIs,
 KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy,
 writePolicy);
 _LIT_SECURITY_POLICY_PASS( KReadPolicy);
 _LIT_SECURITY_POLICY_C1(KWritePolicy, ECapabilityWriteDeviceData);
 ret = RProperty::Define(KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus, RProperty::EInt, KReadPolicy,
 KWritePolicy);
+//User::LeaveIfError( RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,
+//               EAutolockOff));
+RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,
+EAutolockOff);
 RDEBUG("defined KCoreAppUIsAutolockStatus", ret);
 ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus,
 RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass),
 KWritePolicy);
 ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLights,
 RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass),
 TSecurityPolicy(TSecurityPolicy::EAlwaysPass));
 RDEBUG("defined KAknKeyguardStatus", ret);
+ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsDismissDialog,
+RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass),
+TSecurityPolicy(TSecurityPolicy::EAlwaysPass));
+RDEBUG("defined KSecurityUIsDismissDialog", ret);
 // inactivity
 connect(serviceKeyguard, SIGNAL(active()), this, SLOT(activeKeyguard()));
 connect(serviceKeyguard, SIGNAL(notActive()), this, SLOT(
 notActiveKeyguard()));
 void AutolockSrv::adjustInactivityTimers(int aReason)
 {
 RDEBUG("aReason", aReason);
 TInt keyguardTime = 0;
 TInt lockTime = 0;
-CRepository* repository;
+CRepository* repository = NULL;
 TInt cRresult = 0;
-repository = CRepository::NewL(KCRUidSecuritySettings);
+QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidSecuritySettings) );
 cRresult = repository->Get(KSettingsAutoLockTime, lockTime);	// in minutes, handled internally as seconds
 lockTime *= 60;
 RDEBUG("KSettingsAutoLockTime", KSettingsAutoLockTime);
 RDEBUG("cRresult", cRresult);
 RDEBUG("lockTime", lockTime);
 // from the button
 void AutolockSrv::unlockAction()
 {
 RDEBUG("0", 0);
-TryChangeStatus( ELockAppDisableDevicelock);
+TInt err = TryChangeStatus( ELockAppDisableDevicelock);
+RDEBUG("err", err);
 }
 void AutolockSrv::unguardAction()
 {
 RDEBUG("0", 0);
-TryChangeStatus( ELockAppDisableKeyguard);
+TInt err = TryChangeStatus( ELockAppDisableKeyguard);
+RDEBUG("err", err);
 }
 void AutolockSrv::test1Action()
 {
 RDEBUG("Set(KSettingsAutoLockTime, 2)", 2);
-CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);
+CRepository* repositorySet = NULL;
+QT_TRAP_THROWING( repositorySet = CRepository::NewL(KCRUidSecuritySettings) );
 repositorySet->Set(KSettingsAutoLockTime, 2);	// in minutes
 delete repositorySet;
 }
 void AutolockSrv::test2Action()
 {
 RDEBUG("Set(KSettingsAutoLockTime, 0)", 0);
-CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);
+CRepository* repositorySet = NULL;
+QT_TRAP_THROWING( repositorySet = CRepository::NewL(KCRUidSecuritySettings) );
 repositorySet->Set(KSettingsAutoLockTime, 0);	// minutes
 delete repositorySet;
+}
+void AutolockSrv::test3Action()
+{
+RDEBUG("SecUiTest", 0);
+RDEBUG("This should start SecUiTest, but it's not done yet", 0);
 }
 int AutolockSrv::AskValidSecCode(int aReason)
 {
 RDEBUG("aReason", aReason);
 {
 User::After( KTimeBeforeRetryingServerConnection);
 }
 err = iTelServer.LoadPhoneModule(KMmTsyModuleName);
 RTelServer::TPhoneInfo PhoneInfo;
-RDEBUG("err", err);
+RDEBUG("LoadPhoneModule err", err);
 err = iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended);
-RDEBUG("err", err);
+RDEBUG("SetExtendedErrorGranularity err", err);
 err = iTelServer.GetPhoneInfo(KPhoneIndex, PhoneInfo);
-RDEBUG("err", err);
+RDEBUG("GetPhoneInfo err", err);
 err = iPhone.Open(iTelServer, PhoneInfo.iName);
-RDEBUG("err", err);
+RDEBUG("Open err", err);
 err = iCustomPhone.Open(iPhone);
-RDEBUG("err", err);
+RDEBUG("Open2 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
+QT_TRAP_THROWING( 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
 ret = status.Int();
 RDEBUG( "WaitForRequestL ret", ret );
 #else
 RDEBUG("! OLD_METHOD", 0);
 CWait *iWait = NULL;
-iWait = CWait::NewL();
+QT_TRAP_THROWING( iWait = CWait::NewL() );
 iWait->SetRequestType(EMobilePhoneSetLockSetting);
 iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange); // ask for PassPhraseRequiredL
 RDEBUG("WaitForRequestL", 0);
-ret = iWait->WaitForRequestL();
+QT_TRAP_THROWING( ret = iWait->WaitForRequestL() );
 RDEBUG("WaitForRequestL ret", ret);
 if (iWait)
 {
 RDEBUG("IsActive", 0);
 if (iWait->IsActive())
 validCode = 1;
 else
 validCode = 0;
 }
 else
+		{
+		RDEBUG("RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);
+		RDEBUG("lockInfo.iSetting = RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);
 validCode = 0x20;
+	}
 }
 else
+{
+RDEBUG("Error: ret", ret);
 validCode = 0x21;
+	}
 /* Alternative way to ask for password
 RMobilePhone::TMobilePhoneSecurityEvent iEvent;
 TInt result = KErrNone;
 iEvent = RMobilePhone::EPhonePasswordRequired;
 validCode = true;
 RDEBUG( "result", result );
 */
 }
 // TODO this doesn't wait on WINS , so how do I get the Acceptation?
-RDEBUG("validCode (true/false)", validCode);
+RDEBUG("validCode", validCode);
-if (validCode)
+if (validCode>0)
 return KErrNone;
 		// no valid code -> switch off the lights
 err = RProperty::Set(KPSUidSecurityUIs,
 KSecurityUIsLights, ESecurityUIsLightsLockOffRequest);
 }
 void AutolockSrv::lockAction()
 {
 RDEBUG("0", 0);
-XQSERVICE_DEBUG_PRINT("AutolockSrv::lockAction");
 TryChangeStatus( ELockAppOfferDevicelock);
 }
 void AutolockSrv::handleAnswerDelivered()
 {
 RDEBUG("0", 0);
 int AutolockSrv::publishStatus(int aReason)
 {
 RDEBUG("aReason", aReason);
 TInt err;
+// can't use include file because it's private file. However it gives permissions
 const TUid KCRUidCoreApplicationUIsSysAp = { 0x101F8765 };
 const TUint32 KSysApKeyguardActive = 0x00000001;
-CRepository* repositoryDevicelock;
+CRepository* repositoryDevicelock = NULL;
-CRepository* repositoryKeyguard;
+CRepository* repositoryKeyguard = NULL;
-repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings);
+QT_TRAP_THROWING( repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings) );
-repositoryKeyguard = CRepository::NewL(KCRUidCoreApplicationUIsSysAp);
+QT_TRAP_THROWING( repositoryKeyguard = CRepository::NewL(KCRUidCoreApplicationUIsSysAp) );
 TInt cRresult = KErrNone;
 if (1 == 1) // this is a quick way to disable this functionality, for testing
 {
 RDEBUG("publishing", aReason);
 if (aReason == ELockNotActive)
 RDEBUG("cRresult", cRresult);
 }
 else if (aReason >= EDevicelockActive)
 {
 err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus,
-EKeyguardAutolockEmulation); // not EKeyguardLocked, not EKeyguardNotActive
+EKeyguardAutolockEmulation); // Other candidates might be: EKeyguardLocked and EKeyguardNotActive
 		RDEBUG("KAknKeyguardStatus err", err);
 err = RProperty::Set(KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus, EManualLocked);
 		RDEBUG("KCoreAppUIsAutolockStatus err", err);
 err = RProperty::Set(KPSUidSecurityUIs,
 RDEBUG("aReason", aReason);
 int ret = aReason;
 int errorInProcess = KErrNone;
 DebugRequest(ret);
+TInt err = RProperty::Set(KPSUidSecurityUIs,
+KSecurityUIsDismissDialog,
+ESecurityUIsDismissDialogOn);
+		RDEBUG("err", err);
 switch (ret)
 {
 case ELockAppEnableKeyguard: // 1
 {
 errorInProcess = CheckIfLegal(ret);
 if (errorInProcess == KErrNone)
 {
 if (!callerHasECapabilityWriteDeviceData) // check permissions for calling process, because doesn't AskValidSecCode
 errorInProcess = KErrPermissionDenied;
 DebugError(errorInProcess);
+break;	// so that "disable while disabled" doesn't mess up
 }
 if (errorInProcess == KErrNone)
 {
 RDEBUG(" calling HbDeviceMessageBox::question", 0);
-bool value = HbDeviceMessageBox::question("Disable Lock?");
+bool value = HbDeviceMessageBox::question("Disable Lock?");	// this doesn't block other events, so after return everything might be messed up.
 RDEBUG("value", value);
 if (!value)
 errorInProcess = KErrCancel;
 }
 if (errorInProcess == KErrNone)
 updateIndicator(ELockNotActive);
 publishStatus(ELockNotActive);
 }
 if (errorInProcess != KErrNone)
 { // re-lock. For example, if password is wrong
-setLockDialog(aReason, 1);
+	if( iLockStatus >=EDevicelockActive)	// this skips the case when unlocking, although it wan't locked.
+	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?");
+bool value = HbDeviceMessageBox::question("Enable Keyguard?");	// this doesn't block other events, so after return everything might be messed up.
 // TODO what about a nice icon?
 RDEBUG("value", value);
 if (!value)
 errorInProcess = KErrCancel;
 }
 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)
 {
+RDEBUG("ELockAppOfferDevicelock calling ELockAppEnableDevicelock", ELockAppEnableDevicelock);
 errorInProcess = TryChangeStatus(ELockAppEnableDevicelock);
 }
 // this never shows a note. Perhaps ELockAppEnableDevicelock does.
 }
 break;
 // confirm that dialog is present
 err = iDeviceDialog->error();
 RDEBUG("err", err);
 iDeviceDialogCreated = 2;
 }
-const QString KSecQueryUiDeviceDialog(
+const QString KSecQueryUiDeviceDialog("com.nokia.secuinotificationdialog/1.0");
-"com.nokia.secuinotificationdialog/1.0");
 RDEBUG("pre show", aReason);
 err = iDeviceDialog->show(KSecQueryUiDeviceDialog, params); // and continue processing
 RDEBUG("post show. err", err);
 err = iDeviceDialog->error();
 RDEBUG("err", err);
 int AutolockSrv::updateIndicator(int aReason)
 {
 RDEBUG("aReason", aReason);
 QList<QVariant> list;
 list.insert(0, 1);
-list.insert(1, "aaa");
+list.insert(1, "dummy");
 list.insert(2, 2);
 HbIndicator indicator;
 bool success;
 if (aReason == ELockNotActive)
 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);
+RDEBUG("KeyPress", keyEvent->key());
-qDebug() << keyEvent->key();
-qDebug() << EKeyInsert;
-qDebug() << (keyEvent->key() & 0xFF);
-qDebug() << (EKeyInsert & 0xFF);
 if ((keyEvent->key() & 0xFF) == (EKeyInsert & 0xFF))
 {
-qDebug() << "pressed EKeyInsert";
+RDEBUG("EKeyInsert", EKeyInsert);
 // only reacts on release, not on press
 isSwitchKey = 1;
 }
 if ((keyEvent->key() & 0xFF) == (EKeyTab & 0xFF))
 {
-qDebug() << "pressed EKeyTab";
+RDEBUG("EKeyTab", EKeyTab);
 }
 if ((keyEvent->key() & 0xFF) == (EKeyDeviceF & 0xFF))
 {
-qDebug() << "pressed EKeyDeviceF";
+RDEBUG("EKeyDeviceF", EKeyDeviceF);
 }
 if (keyEvent->key() == 0x1ffffff)
 {
-qDebug() << "pressed EKeyDeviceF-1ffffff";
+RDEBUG("0x1ffffff", 0x1ffffff);
 isSwitchKey = 1;
 }
 }
 else if (ev->type() == QEvent::KeyRelease)
 {
 QKeyEvent *keyEvent = static_cast<QKeyEvent *> (ev);
-qDebug()
+RDEBUG("KeyRelease", keyEvent->key());
-<< 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)
 }
 // this never happens
 RDEBUG("0", 0);
 return QWidget::eventFilter(o, ev);
 }
+// some setting changed
 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;
+}
+// some environment changed
+void AutolockSrv::subscriberKAknKeyguardStatusChanged()
+{
+RDEBUG("Error only AutolockSrv should be able to change it", 0);
+	}
+void AutolockSrv::subscriberKCoreAppUIsAutolockStatusChanged()
+{
+RDEBUG("Error only AutolockSrv should be able to change it", 0);
+	}
+void AutolockSrv::subscriberKHWRMGripStatusChanged()
+{
+TInt ret;
+RDEBUG("0", 0);
+TInt aGripStatus;
+TInt err = RProperty::Get(KPSUidHWRM, KHWRMGripStatus, aGripStatus );
+RDEBUG("err", err);
+RDEBUG("value", aGripStatus);
+if( aGripStatus == EPSHWRMGripOpen )
+	{
+if (iLockStatus == EKeyguardActive)
+{
+iShowKeyguardNote = 1; // note on disable keyguard
+ret = TryChangeStatus(ELockAppDisableKeyguard);
+}
+else if (iLockStatus == EDevicelockActive)
+{
+ret = TryChangeStatus(ELockAppDisableDevicelock);
+}
+}
+else if( aGripStatus == EPSHWRMGripClosed )
+	{
+if (iLockStatus == ELockNotActive)
+{
+iShowKeyguardNote = 1; // note on enable keyguard
+ret = TryChangeStatus(ELockAppEnableKeyguard);
+}
+	}
 }
 // ----------AutolockSrvService---------------
 AutolockSrvService::AutolockSrvService(AutolockSrv* parent) :
 void AutolockSrvService::complete(QString number)
 {
 RDEBUG("0", 0);
 if (mAsyncReqId == -1)
 return;
-XQSERVICE_DEBUG_PRINT("AutolockSrvService::complete");
 completeRequest(mAsyncReqId, number.toInt());
 }
-// gor API request
+// got API request from lockaccessextension
 int AutolockSrvService::service(const QString& number,
 const QString& aParam1, const QString& aParam2)
 {
 RDEBUG("0", 0);
 TInt err = KErrNone;
-qDebug() << "number=" << number;
+RDEBUG("number", number.toInt());
-qDebug() << "aParam1=" << aParam1;
+RDEBUG("aParam1", aParam1.toInt());
-qDebug() << "aParam2=" << aParam2;
+RDEBUG("aParam2", aParam2.toInt());
 mAsyncAnswer = false;
 XQRequestInfo info = requestInfo();
 QSet<int> caps = info.clientCapabilities();
 mAutolockSrv->callerHasECapabilityWriteDeviceData = 0;
 RDEBUG("myTimeHigh", myTimeHigh);
 err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow );
 RDEBUG("err", err);
 RDEBUG("myTimeLow", myTimeLow);
-myTimeHigh = myTime.Int64() >> 16;
+myTimeHigh = I64HIGH( myTime.Int64() );
-myTimeLow = myTime.Int64() & 0xFFFFFFFF ;
+myTimeLow = I64LOW( myTime.Int64() );
 RDEBUG("myTimeHigh", myTimeHigh);
 RDEBUG("myTimeLow", myTimeLow);
 err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh );
 err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow );

changeset 22	6b63ca65093a
parent 19	098e361762d2