securitydialogs/Autolock/src/Autolock.cpp
changeset 26 aad866c37519
child 37 7bad16cccaca
child 63 989397f9511c
--- /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 <QCoreApplication>
+#include <QKeyEvent>
+#include <QEvent>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QStackedWidget>
+#include <QImageReader>
+#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 <lockappclientserver.h>
+
+#include <xqsharablefile.h>
+
+#include <QGraphicsLinearLayout>
+
+#include <hblabel.h>
+
+#include "Autolock.h"
+#include <xqserviceutil.h>
+
+#include "autolockuseractivityservice.h"
+
+#include <settingsinternalcrkeys.h>		// CenRep keys
+#include <w32std.h>
+#include <eikenv.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 "../PubSub/securityuisprivatepskeys.h"
+#include <avkondomainpskeys.h>
+#include <hwrmdomainpskeys.h>
+
+#include <hbdevicedialog.h>
+
+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<QVariant> 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<QKeyEvent *> (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<QKeyEvent *> (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<int> 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;
+    }
+