diff -r 6b63ca65093a -r aad866c37519 securitydialogs/Autolock/src/Autolock.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/securitydialogs/Autolock/src/Autolock.cpp Fri Jun 11 14:28:40 2010 +0300 @@ -0,0 +1,1451 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QTM_USE_NAMESPACE + +#include +#include + +#include + +#include + +#include + +#include + +#include "Autolock.h" +#include + +#include "autolockuseractivityservice.h" + +#include // CenRep keys +#include +#include + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include "../PubSub/securityuisprivatepskeys.h" +#include +#include + +#include + +const TInt KPhoneIndex(0); +const TInt KTriesToConnectServer(2); +const TInt KTimeBeforeRetryingServerConnection(50000); + +#define ESecUiTypeLock 0x00100000 + +_LIT( KMmTsyModuleName, "PhoneTsy"); + +Autolock::Autolock(QWidget *parent, Qt::WFlags f) : + QWidget(parent, f), mService(NULL) + { + RDEBUG("start autolock", 0); + + // The very first thing is to define the properties, so that others can use them. + 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); + + // This is important: we set the status through a property + TInt autolockState; + RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState); + RDEBUG("Get KCoreAppUIsAutolockStatus", ret); + RDEBUG("autolockState", autolockState); + if(autolockState==EAutolockStatusUninitialized) + { + autolockState = EAutolockOff; // not-initialized means taht the unlock-query hasn't been displayed. Therefore the device should not stay locked. + } + ret = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, + autolockState); // this might re-set it. That's not bad. It will re-notify all listeners. + RDEBUG("Set KCoreAppUIsAutolockStatus", ret); + + ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus, + RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), + KWritePolicy); + RDEBUG("defined KAknKeyguardStatus", ret); + + ret = RProperty::Define(KPSUidSecurityUIs, + KSecurityUIsLockInitiatorUID, RProperty::EInt, readPolicy, + writePolicy); + RDEBUG("defined KSecurityUIsLockInitiatorUID", ret); + + ret = RProperty::Define(KPSUidSecurityUIs, + KSecurityUIsLockInitiatorTimeHigh, RProperty::EInt, readPolicy, + writePolicy); + RDEBUG("defined KSecurityUIsLockInitiatorTimeHigh", ret); + ret = RProperty::Define(KPSUidSecurityUIs, + KSecurityUIsLockInitiatorTimeLow, RProperty::EInt, readPolicy, + writePolicy); + RDEBUG("defined KSecurityUIsLockInitiatorTimeLow", ret); + + 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); + + + + mService = new AutolockService(this); + + /* Adjust the palette */ +#if defined(Q_WS_S60) + // this is defined. + 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 + + RDEBUG("connect", 1); + + +#if defined(Q_WS_X11) || defined(Q_WS_WIN) + setFixedSize(QSize(360,640)); // nHD +#elif defined(Q_WS_S60) + // this doesn't work well + // showMaximized(); + showFullScreen(); +#endif + + serviceKeyguard = new AutolockUserActivityService(); + serviceDevicelock = new AutolockUserActivityService(); + + TInt lockValue = 0; + TInt lightsTimeout = 0; + CRepository* repository = NULL; + TInt cRresult = 0; + + iLockStatusPrev = ELockNotActive; + iLockStatus = ELockNotActive; + 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); + + QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidProfileEngine) ); + cRresult = repository->Get(KProEngActiveProfile, lightsTimeout); + // this value is not used for now + delete repository; + + QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidLightSettings) ); + cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout); + // this value is not used for now + delete repository; + + // subscribe to settings changes + 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())); + + // subscribe to environment changes + subscriberKHWRMGripStatus = new QValueSpaceSubscriber( + "/KPSUidHWRM/KHWRMGripStatus"); + connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this, + SLOT(subscriberKHWRMGripStatusChanged())); + + subscriberKAknKeyguardStatus = new QValueSpaceSubscriber( + "/KPSUidAvkonDomain/KAknKeyguardStatus"); + connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this, + SLOT(subscriberKAknKeyguardStatusChanged())); + + subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber( + "/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus"); + connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this, + SLOT(subscriberKCoreAppUIsAutolockStatusChanged())); + + + // 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 AutolockService(this); + } + +Autolock::~Autolock() + { + RDEBUG("0", 0); + delete mService; + } + +void Autolock::adjustInactivityTimers(int aReason) + { + RDEBUG("aReason", aReason); + TInt keyguardTime = 0; + TInt lockTime = 0; + CRepository* repository = NULL; + TInt cRresult = 0; + + QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidSecuritySettings) ); + cRresult = repository->Get(KSettingsAutomaticKeyguardTime, keyguardTime); // in seconds + 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); + } + + cRresult = repository->Get(KSettingsAutoLockTime, lockTime); // in minutes, handled internally as seconds + lockTime *= 60; + RDEBUG("KSettingsAutoLockTime", KSettingsAutoLockTime); + RDEBUG("cRresult", cRresult); + RDEBUG("lockTime", lockTime); + if(lockTime == 65535*60) // Special setting "lock at same time as keyguard" at CpDeviceLockPluginView::GetAutoLockIndex which uses this magic number + lockTime = keyguardTime-2; // lock 2 seconds before before, to avoid keyguard->devicelock sequence + if (lockTime > 60 && lockTime < 24*60*60) // lock timer can't be bigger than 1 day + { + serviceDevicelock->setInactivityPeriod(lockTime); + } + else + { + serviceDevicelock->setInactivityPeriod(12 * 31 * 24 * 60 * 60); // 0x1ea6e00 + } + + + delete repository; + } +void Autolock::quit() + { + RDEBUG("0", 0); + qApp->quit(); + } + +int Autolock::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; + + err = RProperty::Set(KPSUidSecurityUIs, + KSecurityUIsLights, ESecurityUIsLightsQueryOnRequest); + RDEBUG("KSecurityUIsLights err", err); + + RMmCustomAPI iCustomPhone; + while ((err = iTelServer.Connect()) != KErrNone && (thisTry++) + <= KTriesToConnectServer) + { + User::After( KTimeBeforeRetryingServerConnection); + } + err = iTelServer.LoadPhoneModule(KMmTsyModuleName); + RTelServer::TPhoneInfo PhoneInfo; + RDEBUG("LoadPhoneModule err", err); + err = iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended); + RDEBUG("SetExtendedErrorGranularity err", err); + err = iTelServer.GetPhoneInfo(KPhoneIndex, PhoneInfo); + RDEBUG("GetPhoneInfo err", err); + err = iPhone.Open(iTelServer, PhoneInfo.iName); + RDEBUG("Open err", err); + err = iCustomPhone.Open(iPhone); + RDEBUG("Open2 err", err); + + RDEBUG("CSecurityHandler", 0); + CSecurityHandler* handler = new (ELeave) CSecurityHandler(iPhone); + if (aReason == ELockAppDisableDevicelock) + { + RDEBUG("calling AskSecCodeInAutoLockL", 0); + 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 + 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; + QT_TRAP_THROWING( iWait = CWait::NewL() ); + iWait->SetRequestType(EMobilePhoneSetLockSetting); + iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange); // ask for PassPhraseRequiredL + RDEBUG("WaitForRequestL", 0); + QT_TRAP_THROWING( 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 + { + 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; + 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", validCode); + if (validCode>0) + return KErrNone; + + // no valid code -> switch off the lights + err = RProperty::Set(KPSUidSecurityUIs, + KSecurityUIsLights, ESecurityUIsLightsLockOffRequest); + RDEBUG("KSecurityUIsLights err", err); + return KErrCancel; + } + +void Autolock::handleAnswerDelivered() + { + RDEBUG("0", 0); + // quit(); + + } + +void Autolock::setLabelNumber(QString label, QString number) + { + RDEBUG("0", 0); + } + +void Autolock::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 Autolock::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 Autolock::DebugError(int aReason) + { + switch (aReason) + { + case KErrNone: + RDEBUG("KErrNone", aReason); + break; + case KErrPermissionDenied: // caller doesn't have enough capabilities + RDEBUG("KErrPermissionDenied", aReason); + break; + case KErrAlreadyExists: // this particular lock is already enabled + RDEBUG("KErrAlreadyExists", aReason); + break; + case KErrInUse: // the dialog is already shown + RDEBUG("KErrInUse", aReason); + break; + default: + RDEBUG("default", aReason); + break; + } + } + +int Autolock::CheckIfLegal(int aReason) + { + RDEBUG("aReason", aReason); + // check whether a dialog is already displayed. This is to prevent timeout-lock and timeout-keyguard for activated on top of a PIN query, in particular at boot-up (TODO Starter) + TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized); + TInt err = RProperty::Get(KPSUidSecurityUIs, + KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery); + RDEBUG("err", err); + RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery); + switch (aReason) + { + case ELockAppEnableKeyguard: + { + RDEBUG("ELockAppEnableKeyguard iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized) + return KErrInUse; // PIN on top. Don't keyguard + 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); + // no matter whether PIN is displayed + switch (iLockStatus) + { + case ELockNotActive: + return KErrAlreadyExists; + case EKeyguardActive: + return KErrNone; + case EDevicelockActive: + return KErrPermissionDenied; + } + } + break; + case ELockAppEnableDevicelock: + { + RDEBUG("ELockAppEnableDevicelock iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized + && secUiOriginatedQuery + != ESecurityUIsSystemLockOriginated) + return KErrInUse; // PIN on top. Don't devicelock + switch (iLockStatus) + { + case ELockNotActive: + return KErrNone; + case EKeyguardActive: + return KErrNone; + case EDevicelockActive: + return KErrAlreadyExists; + } + } + break; + case ELockAppDisableDevicelock: + { + RDEBUG("ELockAppDisableDevicelock iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized + && secUiOriginatedQuery + != ESecurityUIsSystemLockOriginated) + { + // PIN on top and trying to display unlock-code. This is valid + } + switch (iLockStatus) + { + case ELockNotActive: + return KErrAlreadyExists; + case EKeyguardActive: + return KErrPermissionDenied; + case EDevicelockActive: + return KErrNone; + } + } + break; + case ELockAppOfferKeyguard: + { + RDEBUG("ELockAppOfferKeyguard iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized + && secUiOriginatedQuery + != ESecurityUIsSystemLockOriginated) + return KErrInUse; // PIN on top. Don't offer + switch (iLockStatus) + { + case ELockNotActive: + return KErrNone; + case EKeyguardActive: + return KErrPermissionDenied; + case EDevicelockActive: + return KErrPermissionDenied; + } + } + break; + case ELockAppOfferDevicelock: + { + RDEBUG("ELockAppOfferDevicelock iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized + && secUiOriginatedQuery + != ESecurityUIsSystemLockOriginated) + return KErrInUse; // PIN on top. Don't offer + switch (iLockStatus) + { + case ELockNotActive: + return KErrNone; + case EKeyguardActive: + return KErrNone; + case EDevicelockActive: + return KErrAlreadyExists; + } + } + break; + case ELockAppShowKeysLockedNote: + { + RDEBUG("ELockAppShowKeysLockedNote iLockStatus", iLockStatus); + if (secUiOriginatedQuery + != ESecurityUIsSecUIOriginatedUninitialized + && secUiOriginatedQuery + != ESecurityUIsSystemLockOriginated) + return KErrInUse; // PIN on top. Don't display + 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 Autolock::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 = NULL; + CRepository* repositoryKeyguard = NULL; + QT_TRAP_THROWING( repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings) ); + 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) + { + err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, + EKeyguardNotActive); + RDEBUG("err", err); + err = RProperty::Set(KPSUidCoreApplicationUIs, + KCoreAppUIsAutolockStatus, EAutolockOff); + RDEBUG("err", err); + // lights are required ? + + // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0); // the settings remains. Only ISA changes, as well as the P&S + cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0); + RDEBUG("cRresult", cRresult); + } + if (1 == 1) // this is a quick way to disable this functionality, for testing + { + if (aReason == EKeyguardActive) + { + err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, + EKeyguardLocked); + RDEBUG("KAknKeyguardStatus err", err); + err = RProperty::Set(KPSUidCoreApplicationUIs, + KCoreAppUIsAutolockStatus, EAutolockOff); + RDEBUG("KCoreAppUIsAutolockStatus err", err); + err = RProperty::Set(KPSUidSecurityUIs, + KSecurityUIsLights, ESecurityUIsLightsLockOffRequest); // same for keyguard and devicelock + RDEBUG("KSecurityUIsLights err", err); + // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0); + cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 1); + RDEBUG("cRresult", cRresult); + } + else if (aReason >= EDevicelockActive) + { + err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, + 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, + KSecurityUIsLights, ESecurityUIsLightsLockOffRequest); + RDEBUG(" KSecurityUIsLights err", err); + // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 1); + cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0); // keyguard disabled, so that user can type and DeviceF can be captured + RDEBUG("cRresult", cRresult); + } + } + } + delete repositoryDevicelock; + delete repositoryKeyguard; + // this is the real point where everything is done. + iLockStatusPrev = iLockStatus; + iLockStatus = aReason; + RDEBUG("setting iLockStatus", iLockStatus); + return KErrNone; + } +/********************/ +int Autolock::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 Autolock::TryChangeStatus(int aReason) + { + 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); + 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) + { + setLockDialog(aReason, 0); // hide temporarilly because HbDeviceMessageBox doesn't get in top of the Lock-icon. Thus, dismiss it. + RDEBUG("calling HbDeviceMessageBox::question", 0); + 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) + { + 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 + if( iLockStatus >=EDevicelockActive) // this skips the case "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?"); // 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; + } + if (errorInProcess == KErrNone) + { + errorInProcess = TryChangeStatus(ELockAppEnableKeyguard); + } + // this never shows a note + } + break; + case ELockAppOfferDevicelock: // 6 + { + errorInProcess = CheckIfLegal(ret); + DebugError(errorInProcess); + if (errorInProcess == KErrNone) + { + 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; + case ELockAppShowKeysLockedNote: // 7 + { + errorInProcess = CheckIfLegal(ret); // it will not be legal if the keyguard is not enabled and the devicelock is not enabled. + DebugError(errorInProcess); + if (errorInProcess == KErrNone) + { + 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 Autolock::setLockDialog(int aReason, int status) + { + RDEBUG("aReason", aReason); + RDEBUG("status", status); + RDEBUG("iDeviceDialogCreated", iDeviceDialogCreated); + TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized); + TInt err = RProperty::Get(KPSUidSecurityUIs, + KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery); + RDEBUG("err", err); + RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery); + + if (status == 0) // hide + { + // secUiOriginatedQuery should be ESecurityUIsSystemLockOriginated . If not, this is not correctly setting it + if (iDeviceDialogCreated > 0) + { + iDeviceDialogCreated = 0; + iDeviceDialog->cancel(); + err = iDeviceDialog->error(); + RDEBUG("err", err); + TInt err = RProperty::Set(KPSUidSecurityUIs, + KSecurityUIsSecUIOriginatedQuery, + ESecurityUIsSecUIOriginatedUninitialized); + RDEBUG("err", err); + } + } + else if (status == 1) // show + { + // secUiOriginatedQuery should be ESecurityUIsSecUIOriginatedUninitialized . If not, the validation is not correctly filtering it + 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); // and continue processing + RDEBUG("post show. err", err); + err = iDeviceDialog->error(); + RDEBUG("err", err); + // This won't be needed when screensaver is in place, as the dialogs will be different, and therefore both can be present + // Somehow this should be handled by Orbit, but unfortunatelly they don't allow the same dialog twice + err = RProperty::Set(KPSUidSecurityUIs, + KSecurityUIsSecUIOriginatedQuery, + ESecurityUIsSecUIOriginatedUninitialized); // TODO this should be ESecurityUIsSystemLockOriginated ? + RDEBUG("err", err); + + } + else + { + RDEBUG("unknown status", status); + return KErrNotSupported; + } + return KErrNone; + } +void Autolock::setLabelIcon(int aReason) + { + RDEBUG("aReason", aReason); + + if (aReason == ELockNotActive) + { + setLockDialog(aReason, 0); // TODO isn't this done already at TryChangeStatus ??? + lower(); + hide(); + } + else if (aReason == EKeyguardActive) + { + setLockDialog(aReason, 1); + // this shows the Autolock Application. not needed + } + else if (aReason == EDevicelockActive) + { + } + else + { + RDEBUG("error: aReason", aReason); + } + } + +int Autolock::updateIndicator(int aReason) + { + RDEBUG("aReason", aReason); + QList list; + list.insert(0, 1); + list.insert(1, "dummy"); + list.insert(2, 2); + + HbIndicator indicator; + bool success; + if (aReason == ELockNotActive) + success = indicator.deactivate( + "com.nokia.hb.indicator.autolock.autolock_8/1.0"); // maybe it's already deactivated. Not a problem + else if (aReason == EKeyguardActive) + success = indicator.activate( + "com.nokia.hb.indicator.autolock.autolock_8/1.0"); + else if (aReason == EDevicelockActive) + success = indicator.activate( + "com.nokia.hb.indicator.autolock.autolock_8/1.0"); // same. We have just 1 indicator + else + success = 0; + RDEBUG("success", success); + return success; + } + +void Autolock::activeKeyguard() + { + // activity while keyguarded. Nothing to do + RDEBUG("0", 0); + } + +void Autolock::notActiveKeyguard() + { + // inactivity. Keyguard should be activated + RDEBUG("0", 0); + int ret = KErrNone; + DebugStatus( iLockStatus); + if (iLockStatus == ELockNotActive) // not possible if it's keyguarded, or locked + { + ret = TryChangeStatus(ELockAppEnableKeyguard); + } + RDEBUG("ret", ret); + } +/* Some activity detected while the deviceLock is enabled */ +void Autolock::activeDevicelock() + { + // nothing to do + RDEBUG("0", 0); + } + +void Autolock::notActiveDevicelock() + { + // inactivity. Devicelock should be activated + RDEBUG("0", 0); + int ret = KErrNone; + DebugStatus( iLockStatus); + if (iLockStatus == ELockNotActive || iLockStatus == EKeyguardActive) // not possible if it's locked + { + ret = TryChangeStatus(ELockAppEnableDevicelock); + } + RDEBUG("ret", ret); + + } + +// some key is pressed +bool Autolock::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 (ev); + RDEBUG("KeyPress", keyEvent->key()); + RDEBUG("KeyPress nativeScanCode", keyEvent->nativeScanCode()); + RDEBUG("EStdKeyDeviceF", EStdKeyDeviceF); + RDEBUG("keyEvent->isAutoRepeat()", keyEvent->isAutoRepeat()); + if( !keyEvent->isAutoRepeat() ) + { + if ((keyEvent->key() & 0xFF) == (EKeyInsert & 0xFF)) + { + RDEBUG("EKeyInsert", EKeyInsert); + // only reacts on release, not on press + isSwitchKey = 1; + } + if ((keyEvent->key() & 0xFF) == (EKeyDeviceF & 0xFF)) + { + RDEBUG("EKeyDeviceF", EKeyDeviceF); + } + if (keyEvent->key() == 0x1ffffff) + { + RDEBUG("0x1ffffff", 0x1ffffff); // som unknown key is received. Nothing to do + } + if (keyEvent->nativeScanCode() == EStdKeyDeviceF) + { + RDEBUG("got EStdKeyDeviceF", EStdKeyDeviceF); + isSwitchKey = 1; + } + } + else if (ev->type() == QEvent::KeyRelease) + { + QKeyEvent *keyEvent = static_cast (ev); + RDEBUG("KeyRelease", keyEvent->key()); + RDEBUG("KeyRelease native", keyEvent->nativeScanCode()); + if (keyEvent->nativeScanCode() == EStdKeyDeviceF && !keyEvent->isAutoRepeat()) + { + RDEBUG("released EStdKeyDeviceF", 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 = KErrNone; + 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); + } + else + { + RDEBUG("unknown iLockStatus", iLockStatus); + } + RDEBUG("ret", ret); + } // isSwitchKey + } // ev + // Process if not done before. For example, redraw or quit + return QWidget::event(ev); + } + +bool Autolock::eventFilter(QObject *o, QEvent *ev) + { + // this never happens + RDEBUG("0", 0); + return QWidget::eventFilter(o, ev); + } +// some setting changed +void Autolock::subscriberKSettingsAutolockStatusChanged() + { + RDEBUG("0", 0); + QVariant v = subscriberKSettingsAutolockStatus->value( + "/KCRUidSecuritySettings/KSettingsAutolockStatus"); + adjustInactivityTimers( KSettingsAutolockStatus); + } +void Autolock::subscriberKSettingsAutoLockTimeChanged() + { + RDEBUG("0", 0); + QVariant v = subscriberKSettingsAutoLockTime->value( + "/KCRUidSecuritySettings/KSettingsAutoLockTime"); + adjustInactivityTimers( KSettingsAutoLockTime); + } +void Autolock::subscriberKSettingsAutomaticKeyguardTimeChanged() + { + RDEBUG("0", 0); + QVariant v = subscriberKSettingsAutomaticKeyguardTime->value( + "/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime"); + adjustInactivityTimers( KSettingsAutoLockTime); + } +void Autolock::subscriberKDisplayLightsTimeoutChanged() + { + RDEBUG("0", 0); + QVariant v = subscriberKDisplayLightsTimeout->value( + "/KCRUidLightSettings/KDisplayLightsTimeout"); + // nothing to do + } +void Autolock::subscriberKProEngActiveProfileChanged() + { + RDEBUG("0", 0); + QVariant v = subscriberKProEngActiveProfile->value( + "/KCRUidProfileEngine/KProEngActiveProfile"); + // nothing to do + } +// some environment changed +void Autolock::subscriberKAknKeyguardStatusChanged() + { + RDEBUG("Error only Autolock should be able to change it", 0); + } +void Autolock::subscriberKCoreAppUIsAutolockStatusChanged() + { + RDEBUG("Error only Autolock should be able to change it", 0); + } +void Autolock::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); + } + } + } + +// ----------AutolockService--------------- + +AutolockService::AutolockService(Autolock* parent) : + XQServiceProvider(QLatin1String( + "com.nokia.services.Autolock.Autolock"), parent), + mAutolock(parent), mAsyncReqId(-1), mAsyncAnswer(false) + { + RDEBUG("0", 0); + publishAll(); + connect(this, SIGNAL(returnValueDelivered()), parent, SLOT( + handleAnswerDelivered())); + } + +AutolockService::~AutolockService() + { + RDEBUG("0", 0); + } + +void AutolockService::complete(QString number) + { + RDEBUG("0", 0); + if (mAsyncReqId == -1) + return; + completeRequest(mAsyncReqId, number.toInt()); + } + +// got API request from lockaccessextension +int AutolockService::service(const QString& number, + const QString& aParam1, const QString& aParam2) + { + RDEBUG("0", 0); + TInt err = KErrNone; + RDEBUG("number", number.toInt()); + RDEBUG("aParam1", aParam1.toInt()); + RDEBUG("aParam2", aParam2.toInt()); + mAsyncAnswer = false; + XQRequestInfo info = requestInfo(); + QSet caps = info.clientCapabilities(); + + mAutolock->callerHasECapabilityWriteDeviceData = 0; + if (caps.contains(ECapabilityWriteDeviceData)) + { + RDEBUG("callerHasECapabilityWriteDeviceData", + ECapabilityWriteDeviceData); + mAutolock->callerHasECapabilityWriteDeviceData = 1; + } + + QString label = "Autolock::service:\n"; + label += QString("number=%1\n").arg(number); + + mNumber = number; + mAutolock->setLabelNumber(label, number); + int ret = 0; + ret = number.toInt(); + + mAutolock->mParam1 = aParam1.toInt(); + mAutolock->iShowKeyguardNote = aParam1.toInt(); + mAutolock->mParam2 = aParam2.toInt(); + TTime myTime; + myTime.HomeTime(); + TInt myTimeHigh = 0; + TInt myTimeLow = 0; + err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh ); + RDEBUG("err", err); + RDEBUG("myTimeHigh", myTimeHigh); + err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow ); + RDEBUG("err", err); + RDEBUG("myTimeLow", myTimeLow); + + myTimeHigh = I64HIGH( myTime.Int64() ); + myTimeLow = I64LOW( myTime.Int64() ); + RDEBUG("myTimeHigh", myTimeHigh); + RDEBUG("myTimeLow", myTimeLow); + err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh ); + err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow ); + + ret = mAutolock->TryChangeStatus(ret); + RDEBUG("ret", ret); + return ret; + } + +void AutolockService::handleClientDisconnect() + { + RDEBUG("0", 0); + // Just quit service application if client ends + mAsyncAnswer = false; + RDEBUG("0", 0); + // mAutolock->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; + } +