1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  *

     5  * This program is free software: you can redistribute it and/or modify

     6  * it under the terms of the GNU Lesser General Public License as published by

     7  * the Free Software Foundation, version 2.1 of the License.

     8  * 

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU Lesser General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Lesser General Public License

    15  * along with this program.  If not, 

    16  * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

    17  *

    18  * Description:

    19  *

    20  */

    21 

    22 #include <QCoreApplication>

    23 #include <QKeyEvent>

    24 #include <QEvent>

    25 #include <QTimer>

    26 #include <QMessageBox>

    27 #include <QSymbianEvent>

    28 #include <QMainWindow>

    29 #include <qvaluespacesubscriber.h>

    30 #include <qvaluespacepublisher.h>

    31 

    32 QTM_USE_NAMESPACE

    33 

    34 #include <HbIndicator>

    35 #include <hbdevicemessagebox.h>

    36 

    37 #include <lockappclientserver.h>

    38 

    39 #include "Autolock.h"

    40 #include <xqserviceutil.h>

    41 #include "autolockuseractivityservice.h"

    42 #include <settingsinternalcrkeys.h>     // CenRep keys

    43 #include <w32std.h>

    44 #include <eikenv.h>

    45 #include <aknsoundsystem.h>

    46 

    47 #include <secuisecuritysettings.h>

    48 #include <secui.h>

    49 #include <secuisecurityhandler.h>

    50 #include <etelmm.h>

    51 #include <rmmcustomapi.h>

    52 #include <keylockpolicyapi.h>

    53 #include <qvaluespacesubscriber.h>

    54 

    55 #include <hwrmlightdomaincrkeys.h>

    56 #include <ProfileEngineSDKCRKeys.h>

    57 #include <e32property.h>

    58 #include <coreapplicationuisdomainpskeys.h>

    59 #include "../PubSub/securityuisprivatepskeys.h"

    60 #include <avkondomainpskeys.h>

    61 #include <hwrmdomainpskeys.h>

    62 #include <ctsydomainpskeys.h>

    63 

    64 #include <hbdevicedialog.h>

    65 #include <power_save_display_mode.h>

    66 

    67 const TInt KPhoneIndex(0);

    68 const TInt KTriesToConnectServer(2);

    69 const TInt KTimeBeforeRetryingServerConnection(50000);

    70 #define ESecUiTypeLock                  0x00100000

    71 _LIT( KMmTsyModuleName, "PhoneTsy");

    72 

    73 // Constant definitions to control screensaver view types

    74 static const char *KSnsrViewTypeKey = "view_type";

    75 enum TSnsrViewType

    76     {

    77     ESnsrViewTypeInitial = 0, // default initial state, depends on the configuration

    78     ESnsrViewTypeActive,

    79     ESnsrViewTypeStandby,

    80     ESnsrViewTypeDisabled,

    81     };

    82 static const char *KSnsrCmdUnlock = "unlock";

    83 static const char *KSnsrCmdSwitchLights = "switch_lights";

    84 static const char *KSnsrCmdSwitchLowPower = "switch_low_power";

    85 

    86 Autolock::Autolock(QWidget *parent, Qt::WFlags f) :

    87     QWidget(parent, f), mService(NULL)

    88     {

    89     RDEBUG("start autolock", 0);

    90 

    91     // The very first thing is to define the properties, so that others can use them.

    92     TSecurityPolicy readPolicy(ECapabilityReadDeviceData);

    93     TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);

    94     TInt ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy, writePolicy);

    95     RDEBUG("defined KSecurityUIsSecUIOriginatedQuery", ret);

    96     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy, writePolicy);

    97     RDEBUG("defined KSecurityUIsQueryRequestCancel", ret);

    98     _LIT_SECURITY_POLICY_PASS( KReadPolicy);

    99     _LIT_SECURITY_POLICY_C1(KWritePolicy, ECapabilityWriteDeviceData);

   100     ret = RProperty::Define(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, RProperty::EInt, KReadPolicy, KWritePolicy);

   101     RDEBUG("defined KCoreAppUIsAutolockStatus", ret);

   102 

   103     // This is important: we set the status through a property

   104     TInt autolockState;

   105     ret = RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState);

   106     RDEBUG("Get KCoreAppUIsAutolockStatus", ret);

   107     RDEBUG("autolockState", autolockState);

   108     if (autolockState == EAutolockStatusUninitialized)

   109         {

   110         autolockState = EAutolockOff; // not-initialized means taht the unlock-query hasn't been displayed. Therefore the device should not stay locked.

   111         }

   112     ret = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState); // this might re-set it. That's not bad. It will re-notify all listeners.

   113     RDEBUG("Set KCoreAppUIsAutolockStatus", ret);

   114 

   115     ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), KWritePolicy);

   116     RDEBUG("defined KAknKeyguardStatus", ret);

   117 

   118     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLockInitiatorUID, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), writePolicy);

   119     RDEBUG("defined KSecurityUIsLockInitiatorUID", ret);

   120 

   121     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, RProperty::EInt, readPolicy, writePolicy);

   122     RDEBUG("defined KSecurityUIsLockInitiatorTimeHigh", ret);

   123     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, RProperty::EInt, readPolicy, writePolicy);

   124     RDEBUG("defined KSecurityUIsLockInitiatorTimeLow", ret);

   125 

   126     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLights, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), TSecurityPolicy(TSecurityPolicy::EAlwaysPass));

   127     RDEBUG("defined KAknKeyguardStatus", ret);

   128 

   129     ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsDismissDialog, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), TSecurityPolicy(

   130             TSecurityPolicy::EAlwaysPass));

   131     RDEBUG("defined KSecurityUIsDismissDialog", ret);

   132 

   133     mService = new AutolockService(this);

   134 

   135     /* Adjust the palette */

   136 #if defined(Q_WS_S60)

   137     // this is defined.

   138     RDEBUG( "Q_WS_S60", 1 );

   139     QPalette p = qApp->palette();

   140     QColor color(192,192,192);

   141     QColor bg(201,250,250);

   142     p.setColor(QPalette::Highlight, color.lighter(200));

   143     p.setColor(QPalette::Text, Qt::black);

   144     p.setColor(QPalette::Base, bg);

   145     p.setColor(QPalette::WindowText, Qt::black);

   146     p.setColor(QPalette::Window, bg);

   147     p.setColor(QPalette::ButtonText, Qt::black);

   148     p.setColor(QPalette::Button, color.lighter(150));

   149     p.setColor(QPalette::Link, QColor(240,40,40));

   150 

   151     qApp->setPalette(p);

   152 #endif

   153 

   154     RDEBUG("connect", 1);

   155 

   156 #if defined(Q_WS_X11) || defined(Q_WS_WIN)

   157     setFixedSize(QSize(360,640)); // nHD

   158 #elif defined(Q_WS_S60)

   159     // this doesn't work well

   160     // showMaximized();

   161     showFullScreen();

   162 #endif

   163 

   164     serviceKeyguard = new AutolockUserActivityService();

   165     serviceDevicelock = new AutolockUserActivityService();

   166 

   167     TInt lockValue = 0;

   168     TInt lightsTimeout = 0;

   169     CRepository* repository = NULL;

   170     TInt cRresult = 0;

   171     iLockCodeQueryInDisplay = EFalse;

   172     Q_UNUSED(cRresult);

   173 

   174 		iProcessingEvent = -1;

   175     iLockStatusPrev = ELockNotActive;

   176     iLockStatus = ELockNotActive;

   177     QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidSecuritySettings));

   178     cRresult = repository->Get(KSettingsAutolockStatus, lockValue);

   179     RDEBUG("KSettingsAutolockStatus", KSettingsAutolockStatus);

   180     RDEBUG("cRresult", cRresult);

   181     RDEBUG("lockValue", lockValue);

   182     iLockStatus = lockValue;

   183     // the settings says to lock

   184     delete repository;

   185 

   186     adjustInactivityTimers(0);

   187 

   188     QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidProfileEngine));

   189     cRresult = repository->Get(KProEngActiveProfile, lightsTimeout);

   190     // this value is not used for now

   191     delete repository;

   192 

   193     QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidLightSettings));

   194     cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout);

   195     // this value is not used for now

   196     delete repository;

   197 

   198     // subscribe to settings changes

   199     subscriberKSettingsAutolockStatus = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutolockStatus", this);

   200     connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutolockStatusChanged()));

   201     subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutoLockTime", this);

   202     connect(subscriberKSettingsAutoLockTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutoLockTimeChanged()));

   203     subscriberKSettingsAutomaticKeyguardTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime", this);

   204     connect(subscriberKSettingsAutomaticKeyguardTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutomaticKeyguardTimeChanged()));

   205     subscriberKDisplayLightsTimeout = new QValueSpaceSubscriber("/KCRUidLightSettings/KDisplayLightsTimeout", this);

   206     connect(subscriberKDisplayLightsTimeout, SIGNAL(contentsChanged()), this, SLOT(subscriberKDisplayLightsTimeoutChanged()));

   207     subscriberKProEngActiveProfile = new QValueSpaceSubscriber("/KCRUidProfileEngine/KProEngActiveProfile", this);

   208     connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this, SLOT(subscriberKProEngActiveProfileChanged()));

   209 

   210     subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this);

   211     connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));

   212 

   213     // subscribe to environment changes

   214     subscriberKHWRMGripStatus = new QValueSpaceSubscriber("/KPSUidHWRM/KHWRMGripStatus");

   215     connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKHWRMGripStatusChanged()));

   216 

   217     subscriberKAknKeyguardStatus = new QValueSpaceSubscriber("/KPSUidAvkonDomain/KAknKeyguardStatus");

   218     connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKAknKeyguardStatusChanged()));

   219 

   220     subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber("/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus");

   221     connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));

   222 

   223     subscriberKCTsyCallState = new QValueSpaceSubscriber("/KPSUidCtsyCallInformation/KCTsyCallState");

   224     connect(subscriberKCTsyCallState, SIGNAL(contentsChanged()), this, SLOT(subscriberKCTsyCallStateChanged()));

   225 

   226     // inactivity

   227     connect(serviceKeyguard, SIGNAL(active()), this, SLOT(activeKeyguard()));

   228     connect(serviceKeyguard, SIGNAL(notActive()), this, SLOT(notActiveKeyguard()));

   229     connect(serviceDevicelock, SIGNAL(active()), this, SLOT(activeDevicelock()));

   230     connect(serviceDevicelock, SIGNAL(notActive()), this, SLOT(notActiveDevicelock()));

   231 

   232     RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();

   233     RDEBUG("got groupWin", 1);

   234     // if I want to release, I should do:   mKeyCaptureHandle = env->RootWin().CaptureKey(EKeyBackspace, 0, 0);

   235     mEKeyDeviceFCaptureHandle = groupWin.CaptureKey(EKeyDeviceF, 0, 0);

   236     RDEBUG("mEKeyDeviceFCaptureHandle", mEKeyDeviceFCaptureHandle);

   237     mEKeyBellCaptureHandle = groupWin.CaptureKey(EKeyBell, 0, 0);

   238     RDEBUG("mEKeyBellCaptureHandle", mEKeyBellCaptureHandle);

   239     RDEBUG("got mKeyCaptureHandle", 1);

   240 

   241     iSecQueryUiCreated = -1;

   242     iDeviceDialogCreated = EDeviceDialogUninitialized;

   243     RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

   244     iDeviceDialog = NULL;

   245     // for now, always starts unlocked. This is correct because if locked, the unlock-query (from starter) is on top

   246     // TryChangeStatus(iLockStatus);

   247     TryChangeStatus( ELockNotActive);

   248     lower();

   249     hide();

   250 

   251     iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);

   252     connect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), SLOT(handleMessageFromScreensaver(QVariantMap)));

   253     connect(iDeviceDialog, SIGNAL(deviceDialogClosed()), SLOT(handleScreensaverClosed()));

   254 

   255     // screensaver standby mode timer

   256     mScreensaverModeTimer = new QTimer(this);

   257     mScreensaverModeTimer->setInterval(5 * 1000); // milliseconds, TODO: read from cenrep

   258     connect(mScreensaverModeTimer, SIGNAL(timeout()), SLOT(switchScreensaverToPowerSaveMode()));

   259     // screensaver AMOLED low power mode support

   260     mScreensaverPowerSave = CPowerSaveDisplayMode::NewL();

   261     mScreensaverPowerSavePixelBuffer = HBufC16::NewL(360 * 640);

   262     mScreensaverPowerSavePixelBuffer->Des().Fill(0);

   263     }

   264 

   265 Autolock::~Autolock()

   266     {

   267     RDEBUG("0", 0);

   268     delete mService;

   269     delete mScreensaverPowerSave;

   270     delete mScreensaverPowerSavePixelBuffer;

   271     RDEBUG("1", 1);

   272     }

   273 

   274 void Autolock::adjustInactivityTimers(int aReason)

   275     {

   276     RDEBUG("aReason", aReason);

   277     TInt keyguardTime = 0;

   278     TInt lockTime = 0;

   279     CRepository* repository = NULL;

   280     TInt cRresult = 0;

   281     Q_UNUSED(cRresult);

   282 

   283     QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidSecuritySettings));

   284     cRresult = repository->Get(KSettingsAutomaticKeyguardTime, keyguardTime); // in seconds

   285     RDEBUG("KSettingsAutomaticKeyguardTime", KSettingsAutomaticKeyguardTime);

   286     RDEBUG("cRresult", cRresult);

   287     RDEBUG("keyguardTime", keyguardTime);

   288     if (keyguardTime > 0 && keyguardTime < 1000)

   289         {

   290         serviceKeyguard->setInactivityPeriod(keyguardTime);

   291         }

   292     else

   293         {

   294         serviceKeyguard->setInactivityPeriod(12 * 31 * 24 * 60 * 60);

   295         }

   296 

   297     cRresult = repository->Get(KSettingsAutoLockTime, lockTime); // in minutes, handled internally as seconds

   298     lockTime *= 60;

   299     RDEBUG("KSettingsAutoLockTime", KSettingsAutoLockTime);

   300     RDEBUG("cRresult", cRresult);

   301     RDEBUG("lockTime", lockTime);

   302     if (lockTime == 65535 * 60) // Special setting "lock at same time as keyguard" at CpDeviceLockPluginView::GetAutoLockIndex which uses this magic number

   303         lockTime = keyguardTime - 2; // lock 2 seconds before before, to avoid keyguard->devicelock sequence

   304     if (lockTime > 60 && lockTime < 24 * 60 * 60) // lock timer can't be bigger than 1 day

   305         {

   306         serviceDevicelock->setInactivityPeriod(lockTime);

   307         }

   308     else

   309         {

   310         serviceDevicelock->setInactivityPeriod(12 * 31 * 24 * 60 * 60); // 0x1ea6e00

   311         }

   312 

   313     delete repository;

   314     }

   315 void Autolock::quit()

   316     {

   317     RDEBUG("0", 0);

   318     qApp->quit();

   319     }

   320 

   321 int Autolock::AskValidSecCode(int aReason)

   322     {

   323     RDEBUG("aReason", aReason);

   324     RMobilePhone iPhone; // NULL in emulator

   325 

   326 #ifdef __WINS__1

   327     return KErrNone;

   328 #endif

   329 

   330     TInt err(KErrGeneral);

   331     Q_UNUSED(err);

   332     TBool validCode(EFalse);

   333     TInt thisTry(0);

   334     RTelServer iTelServer;

   335 

   336     err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsQueryOnRequest);

   337     RDEBUG("KSecurityUIsLights err", err);

   338 

   339     RMmCustomAPI iCustomPhone;

   340     while ((err = iTelServer.Connect()) != KErrNone && (thisTry++) <= KTriesToConnectServer)

   341         {

   342         User::After( KTimeBeforeRetryingServerConnection);

   343         }

   344     err = iTelServer.LoadPhoneModule(KMmTsyModuleName);

   345     RTelServer::TPhoneInfo PhoneInfo;

   346     RDEBUG("LoadPhoneModule err", err);

   347     err = iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended);

   348     RDEBUG("SetExtendedErrorGranularity err", err);

   349     err = iTelServer.GetPhoneInfo(KPhoneIndex, PhoneInfo);

   350     RDEBUG("GetPhoneInfo err", err);

   351     err = iPhone.Open(iTelServer, PhoneInfo.iName);

   352     RDEBUG("Open err", err);

   353     err = iCustomPhone.Open(iPhone);

   354     RDEBUG("Open2 err", err);

   355 

   356     RDEBUG("CSecurityHandler", 0);

   357     CSecurityHandler* handler = new (ELeave) CSecurityHandler(iPhone);

   358     if (aReason == ELockAppDisableDevicelock)

   359         {

   360         RDEBUG("calling AskSecCodeInAutoLockL", 0);

   361         iLockCodeQueryInDisplay = ETrue;

   362         QT_TRAP_THROWING(validCode = handler->AskSecCodeInAutoLockL()); // this returns true/false

   363         iLockCodeQueryInDisplay = EFalse;

   364         // TODO should this also do iPhone.SetLockSetting(status, lockType, lockChange); ???

   365         }

   366     else if (aReason == ELockAppEnableDevicelock)

   367         {

   368         // check whether code is really needed

   369         RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

   370         RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

   371         RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

   372         RMobilePhone::TMobilePhoneLockSetting lockChange(RMobilePhone::ELockSetDisabled);

   373         TRequestStatus status = KRequestPending;

   374         TInt ret = KErrNone;

   375         RDEBUG("GetLockInfo", 0);

   376         iPhone.GetLockInfo(status, lockType, lockInfoPkg);

   377         RDEBUG("WaitForRequest", 0);

   378         User::WaitForRequest(status);

   379         ret = status.Int();

   380         RDEBUG("WaitForRequest ret", ret);

   381 #ifdef __WINS__

   382         if (ret == KErrTimedOut)

   383             {

   384             ret = KErrNone;

   385             lockInfo.iSetting = RMobilePhone::ELockSetDisabled; // ask password only if there's no timeout.

   386             }

   387 #endif

   388         if (ret == KErrNone)

   389             {

   390             RDEBUG("lockInfo.iSetting", lockInfo.iSetting);

   391             RDEBUG("RMobilePhone::ELockSetDisabled",

   392                     RMobilePhone::ELockSetDisabled);

   393             if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled) // ask password only if there's no timeout

   394                 {

   395                 lockChange = RMobilePhone::ELockSetEnabled;

   396                 RDEBUG("SetLockSetting lockChange", lockChange);

   397 #define OLD_METHODx

   398 #ifdef OLD_METHOD

   399                 status = KRequestPending;

   400                 RDEBUG( "SetLockSetting", 0 );

   401                 iPhone.SetLockSetting(status, lockType, lockChange); // ask for PassPhraseRequiredL

   402                 RDEBUG( "WaitForRequestL", 0 );

   403                 User::WaitForRequest( status ); // TODO this waits 33 seconds in WINS and returns ffffffdf = KErrTimedOut

   404                 ret = status.Int();

   405                 RDEBUG( "WaitForRequestL ret", ret );

   406 #else

   407                 RDEBUG("! OLD_METHOD", 0);

   408                 CWait *iWait = NULL;

   409                 QT_TRAP_THROWING(iWait = CWait::NewL());

   410                 iWait->SetRequestType(EMobilePhoneSetLockSetting);

   411                 iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange); // ask for PassPhraseRequiredL

   412                 RDEBUG("WaitForRequestL", 0);

   413                 QT_TRAP_THROWING(ret = iWait->WaitForRequestL());

   414                 RDEBUG("WaitForRequestL ret", ret);

   415                 if (iWait)

   416                     {

   417                     RDEBUG("IsActive", 0);

   418                     if (iWait->IsActive())

   419                         {

   420                         RDEBUG("CancelAsyncRequest", 0);

   421                         iPhone.CancelAsyncRequest(iWait->GetRequestType());

   422                         RDEBUG("cancelled", 0);

   423                         }

   424                     }

   425                 delete iWait;

   426 #endif

   427 

   428                 RDEBUG("WaitForRequestL ret", ret);

   429 #ifdef __WINS__

   430                 if (ret == KErrTimedOut)

   431                     ret = KErrNone;

   432 #endif

   433                 if (ret == KErrNone)

   434                     validCode = 1;

   435                 else

   436                     validCode = 0;

   437                 }

   438             else

   439                 {

   440                 RDEBUG("RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);

   441                 RDEBUG("lockInfo.iSetting = RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);

   442                 validCode = 0x20;

   443                 }

   444             }

   445         else

   446             {

   447             RDEBUG("Error: ret", ret);

   448             validCode = 0x21;

   449             }

   450 

   451         /* Alternative way to ask for password

   452          RMobilePhone::TMobilePhoneSecurityEvent iEvent;

   453          TInt result = KErrNone;

   454          iEvent = RMobilePhone::EPhonePasswordRequired;

   455          RDEBUG( "calling HandleEventL", 0 );

   456          handler->HandleEventL(iEvent, result); // this is supposed to wait

   457          validCode = false;

   458          if(result)

   459          validCode = true;

   460          RDEBUG( "result", result );

   461          */

   462         }

   463     RDEBUG("validCode", validCode);

   464     if (validCode > 0)

   465         return KErrNone;

   466 

   467     // no valid code -> switch off the lights

   468     err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsLockOffRequest);

   469     RDEBUG("KSecurityUIsLights err", err);

   470     return KErrCancel;

   471     }

   472 

   473 void Autolock::handleAnswerDelivered()

   474     {

   475     RDEBUG("0", 0);

   476     // quit();

   477 

   478     }

   479 

   480 void Autolock::setLabelNumber(QString label, QString number)

   481     {

   482     RDEBUG("0", 0);

   483     }

   484 

   485 void Autolock::DebugRequest(int aReason)

   486     {

   487     switch (aReason)

   488         {

   489         case ELockAppEnableKeyguard:

   490             RDEBUG("ELockAppEnableKeyguard", aReason)

   491             ;

   492             break;

   493         case ELockAppDisableKeyguard:

   494             RDEBUG("ELockAppDisableKeyguard", aReason)

   495             ;

   496             break;

   497         case ELockAppEnableDevicelock:

   498             RDEBUG("ELockAppEnableDevicelock", aReason)

   499             ;

   500             break;

   501         case ELockAppDisableDevicelock:

   502             RDEBUG("ELockAppDisableDevicelock", aReason)

   503             ;

   504             break;

   505         case ELockAppOfferKeyguard:

   506             RDEBUG("ELockAppOfferKeyguard", aReason)

   507             ;

   508             break;

   509         case ELockAppOfferDevicelock:

   510             RDEBUG("ELockAppOfferDevicelock", aReason)

   511             ;

   512             break;

   513         case ELockAppShowKeysLockedNote:

   514             RDEBUG("ELockAppShowKeysLockedNote", aReason)

   515             ;

   516             break;

   517         default:

   518             RDEBUG("default", aReason)

   519             ;

   520             break;

   521         }

   522     }

   523 void Autolock::DebugStatus(int aReason)

   524     {

   525     switch (aReason)

   526         {

   527         case ELockNotActive:

   528             RDEBUG("ELockNotActive", aReason)

   529             ;

   530             break;

   531         case EKeyguardActive:

   532             RDEBUG("EKeyguardActive", aReason)

   533             ;

   534             break;

   535         case EDevicelockActive:

   536             RDEBUG("EDevicelockActive", aReason)

   537             ;

   538             break;

   539         default:

   540             RDEBUG("default", aReason)

   541             ;

   542             break;

   543         }

   544     }

   545 void Autolock::DebugError(int aReason)

   546     {

   547     switch (aReason)

   548         {

   549         case KErrNone:

   550             RDEBUG("KErrNone", aReason)

   551             ;

   552             break;

   553         case KErrPermissionDenied: // caller doesn't have enough capabilities

   554             RDEBUG("KErrPermissionDenied", aReason)

   555             ;

   556             break;

   557         case KErrAlreadyExists: // this particular lock is already enabled

   558             RDEBUG("KErrAlreadyExists", aReason)

   559             ;

   560             break;

   561         case KErrInUse: // the dialog is already shown

   562             RDEBUG("KErrInUse", aReason)

   563             ;

   564             break;

   565         default:

   566             RDEBUG("default", aReason)

   567             ;

   568             break;

   569         }

   570     }

   571 

   572 int Autolock::CheckIfLegal(int aReason)

   573     {

   574     RDEBUG("aReason", aReason);

   575     // check whether a dialog is already displayed. This is to prevent timeout-lock and timeout-keyguard activated on top of a PIN query, in particular at boot-up (TODO check for Starter)

   576     TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized);

   577     TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);

   578     RDEBUG("err", err);

   579     RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);

   580     switch (aReason)

   581         {

   582         case ELockAppEnableKeyguard:

   583             {

   584             RDEBUG("ELockAppEnableKeyguard iLockStatus", iLockStatus);

   585             if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized)

   586                 return KErrInUse; // PIN on top. Don't keyguard

   587             switch (iLockStatus)

   588                 {

   589                 case ELockNotActive:

   590                     if (!CKeyLockPolicyApi::KeyguardAllowed())

   591                         return KErrPermissionDenied;

   592                     else

   593                         return KErrNone;

   594                 case EKeyguardActive:

   595                     return KErrAlreadyExists;

   596                 case EDevicelockActive:

   597                     return KErrPermissionDenied;

   598                 }

   599             }

   600             break;

   601         case ELockAppDisableKeyguard:

   602             {

   603             RDEBUG("ELockAppDisableKeyguard iLockStatus", iLockStatus);

   604             // no matter whether PIN is displayed

   605             switch (iLockStatus)

   606                 {

   607                 case ELockNotActive:

   608                     return KErrAlreadyExists;

   609                 case EKeyguardActive:

   610                     return KErrNone;

   611                 case EDevicelockActive:

   612                     return KErrPermissionDenied;

   613                 }

   614             }

   615             break;

   616         case ELockAppEnableDevicelock:

   617             {

   618             RDEBUG("ELockAppEnableDevicelock iLockStatus", iLockStatus);

   619             if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)

   620                 return KErrInUse; // PIN on top. Don't devicelock

   621             switch (iLockStatus)

   622                 {

   623                 case ELockNotActive:

   624                     return KErrNone;

   625                 case EKeyguardActive:

   626                     return KErrNone;

   627                 case EDevicelockActive:

   628                     return KErrAlreadyExists;

   629                 }

   630             }

   631             break;

   632         case ELockAppDisableDevicelock:

   633             {

   634             RDEBUG("ELockAppDisableDevicelock iLockStatus", iLockStatus);

   635             if (iLockCodeQueryInDisplay)

   636                 {

   637                 // PIN on top and trying to display unlock-code. This is valid

   638                 return KErrAlreadyExists;

   639                 }

   640             switch (iLockStatus)

   641                 {

   642                 case ELockNotActive:

   643                     return KErrAlreadyExists;

   644                 case EKeyguardActive:

   645                     return KErrPermissionDenied;

   646                 case EDevicelockActive:

   647                     return KErrNone;

   648                 }

   649             }

   650             break;

   651         case ELockAppOfferKeyguard:

   652             {

   653             RDEBUG("ELockAppOfferKeyguard iLockStatus", iLockStatus);

   654             if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)

   655                 return KErrInUse; // PIN on top. Don't offer

   656             switch (iLockStatus)

   657                 {

   658                 case ELockNotActive:

   659                     return KErrNone;

   660                 case EKeyguardActive:

   661                     return KErrPermissionDenied;

   662                 case EDevicelockActive:

   663                     return KErrPermissionDenied;

   664                 }

   665             }

   666             break;

   667         case ELockAppOfferDevicelock:

   668             {

   669             RDEBUG("ELockAppOfferDevicelock iLockStatus", iLockStatus);

   670             if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)

   671                 return KErrInUse; // PIN on top. Don't offer

   672             switch (iLockStatus)

   673                 {

   674                 case ELockNotActive:

   675                     return KErrNone;

   676                 case EKeyguardActive:

   677                     return KErrNone;

   678                 case EDevicelockActive:

   679                     return KErrAlreadyExists;

   680                 }

   681             }

   682             break;

   683         case ELockAppShowKeysLockedNote:

   684             {

   685             RDEBUG("ELockAppShowKeysLockedNote iLockStatus", iLockStatus);

   686             if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)

   687                 return KErrInUse; // PIN on top. Don't display

   688             switch (iLockStatus)

   689                 {

   690                 case ELockNotActive:

   691                     return KErrPermissionDenied;

   692                 case EKeyguardActive:

   693                     return KErrNone;

   694                 case EDevicelockActive: // TODO confirm this. CMMKeyBearer::ReceivedKeyEvent expects KErrNone if keypad is locked

   695                     return KErrPermissionDenied;

   696                 }

   697             }

   698             break;

   699         default:

   700             {

   701             RDEBUG("default iLockStatus", iLockStatus);

   702             return KErrPermissionDenied;

   703             }

   704             // break;

   705         } // switch

   706     return KErrPermissionDenied;

   707     }

   708 

   709 int Autolock::publishStatus(int aReason)

   710     {

   711     RDEBUG("aReason", aReason);

   712     Q_UNUSED(aReason);

   713     TInt err = KErrNone;

   714     Q_UNUSED(err);

   715     // can't use include file because it's private file. However it gives permissions

   716     const TUid KCRUidCoreApplicationUIsSysAp =

   717         {

   718         0x101F8765

   719         };

   720     const TUint32 KSysApKeyguardActive = 0x00000001;

   721     CRepository* repositoryDevicelock = NULL;

   722     CRepository* repositoryKeyguard = NULL;

   723     QT_TRAP_THROWING(repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings));

   724     QT_TRAP_THROWING(repositoryKeyguard = CRepository::NewL(KCRUidCoreApplicationUIsSysAp));

   725     TInt cRresult = KErrNone;

   726     Q_UNUSED(cRresult);

   727     if (1 == 1) // this is a quick way to disable this functionality, for testing

   728         {

   729         RDEBUG("publishing", aReason);

   730         if (aReason == ELockNotActive)

   731             {

   732             err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardNotActive);

   733             RDEBUG("err", err);

   734             err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

   735             RDEBUG("err", err);

   736             err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsLockOnRequest); // lights are required

   737             RDEBUG("KSecurityUIsLights err", err);

   738 

   739             // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0);    // the settings remains. Only ISA changes, as well as the P&S

   740             cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0);

   741             RDEBUG("cRresult", cRresult);

   742             }

   743         if (1 == 1) // this is a quick way to disable this functionality, for testing

   744             {

   745             if (aReason == EKeyguardActive)

   746                 {

   747                 err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardLocked);

   748                 RDEBUG("KAknKeyguardStatus err", err);

   749                 err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

   750                 RDEBUG("KCoreAppUIsAutolockStatus err", err);

   751                 err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsLockOffRequest); // same for keyguard and devicelock

   752                 RDEBUG("KSecurityUIsLights err", err);

   753                 // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0);

   754                 cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 1);

   755                 RDEBUG("cRresult", cRresult);

   756                 }

   757             else if (aReason >= EDevicelockActive)

   758                 {

   759                 err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardAutolockEmulation); // Other candidates might be: EKeyguardLocked and EKeyguardNotActive

   760                 RDEBUG("KAknKeyguardStatus err", err);

   761                 err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EManualLocked);

   762                 RDEBUG("KCoreAppUIsAutolockStatus err", err);

   763                 err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsLockOffRequest);

   764                 RDEBUG(" KSecurityUIsLights err", err);

   765                 // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 1);

   766                 cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 0); // keyguard disabled, so that user can type and DeviceF can be captured

   767                 RDEBUG("cRresult", cRresult);

   768                 }

   769             }

   770         }

   771     delete repositoryDevicelock;

   772     delete repositoryKeyguard;

   773     // this is the real point where everything is done.

   774     iLockStatusPrev = iLockStatus;

   775     iLockStatus = aReason;

   776     RDEBUG("setting iLockStatus", iLockStatus);

   777     return KErrNone;

   778     }

   779 /********************/

   780 int Autolock::showNoteIfRequested(int aReason)

   781     {

   782     RDEBUG("aReason", aReason);

   783     // The notes are displayed. This is useful only for the API withNote, and ELockAppShowKeysLockedNote

   784     // However, it has some inconvenients:

   785     // - the screensaver already displays/hides

   786     // - the notes are shown behing the icon because they have lower priorities

   787     // - they are annoying

   788     // TODO translate

   789     if (aReason == ELockNotActive)

   790         {

   791         if (iShowKeyguardNote == 1)

   792             {

   793             HbDeviceMessageBox::information("Keyguard deactivated");

   794             }

   795         }

   796     else if (aReason == EKeyguardActive)

   797         {

   798         if (iShowKeyguardNote == 1)

   799             {

   800             HbDeviceMessageBox::information("Keyguard activated");

   801             // this already waits a bit because the lock-icon takes some time to display. So the note is visible before the lock-icon.

   802             }

   803         }

   804     else if (aReason >= EDevicelockActive) // this doesn't happen, but we are prepared nevertheless

   805         {

   806         if (iShowKeyguardNote == 1)

   807             {

   808             HbDeviceMessageBox::information("Devicelock activated");

   809             }

   810         }

   811     return KErrNone;

   812     }

   813 /***********************/

   814 int Autolock::TryChangeStatus(int aReason)

   815     {

   816     RDEBUG("aReason", aReason);

   817     int ret = aReason;

   818     int errorInProcess = KErrNone;

   819     DebugRequest(ret);

   820 

   821     // this will cancel any previous dialog, i.e. PIN query, or any previous code-request.

   822     // not sure about the screensaver, but nevertheless will be cancelled when the status is changed.

   823     TInt err = KErrNone;

   824     Q_UNUSED(err);

   825     RDEBUG("Not setting KSecurityUIsDismissDialog ESecurityUIsDismissDialogOn", ESecurityUIsDismissDialogOn);

   826     //// err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogOn);

   827     RDEBUG("err", err);

   828     switch (ret)

   829         {

   830         case ELockAppEnableKeyguard: // 1

   831             {

   832             errorInProcess = CheckIfLegal(ret);

   833             DebugError(errorInProcess);

   834             if (errorInProcess == KErrNone)

   835                 {

   836                 showNoteIfRequested( EKeyguardActive);

   837                 setLabelIcon(EKeyguardActive);

   838                 updateIndicator(EKeyguardActive);

   839                 publishStatus(EKeyguardActive);

   840                 setLockDialog(aReason, 1);

   841                 }

   842             }

   843             break;

   844         case ELockAppDisableKeyguard: // 2

   845             {

   846             errorInProcess = CheckIfLegal(ret);

   847             DebugError(errorInProcess);

   848             if (errorInProcess == KErrNone)

   849                 {

   850                 showNoteIfRequested( ELockNotActive);

   851                 setLabelIcon(ELockNotActive);

   852                 updateIndicator(ELockNotActive);

   853                 publishStatus(ELockNotActive);

   854                 setLockDialog(aReason, 0);

   855                 }

   856             }

   857             break;

   858         case ELockAppEnableDevicelock: // 3

   859             {

   860             errorInProcess = CheckIfLegal(ret);

   861             DebugError(errorInProcess);

   862             if (errorInProcess == KErrNone)

   863                 {

   864                 if (!callerHasECapabilityWriteDeviceData) // check permissions for calling process, because doesn't AskValidSecCode

   865                     errorInProcess = KErrPermissionDenied;

   866                 DebugError(errorInProcess);

   867                 }

   868             if (errorInProcess == KErrNone)

   869                 {

   870                 updateIndicator( EDevicelockActive);

   871                 publishStatus(EDevicelockActive);

   872                 setLabelIcon(EDevicelockActive);

   873                 setLockDialog(aReason, 1);

   874                 }

   875             // aParam1 is aReason : EDevicelockManual, EDevicelockRemote

   876             // this never shows a note

   877             }

   878             break;

   879         case ELockAppDisableDevicelock: // 4

   880             {

   881             errorInProcess = CheckIfLegal(ret);

   882             DebugError(errorInProcess);

   883             if (errorInProcess == KErrNone)

   884                 {

   885                 if (!callerHasECapabilityWriteDeviceData) // check permissions for calling process, because doesn't AskValidSecCode

   886                     errorInProcess = KErrPermissionDenied;

   887                 DebugError(errorInProcess);

   888                 }

   889             if (errorInProcess == KErrNone)

   890                 {

   891                 setLockDialog(aReason, 0); // hide temporarilly because HbDeviceMessageBox doesn't get in top of the Lock-icon. Thus, dismiss it.

   892                 // do I need to enable touch? it seems to work without it

   893                 // in any case, lights are needed

   894                 err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, ESecurityUIsLightsQueryOnRequest);

   895                 RDEBUG("calling HbDeviceMessageBox::question", 0);

   896                 bool value = true;

   897                 // not sure whether this question is really needed. The UI doesn't say anything, so I remove it for now.

   898                 // HbDeviceMessageBox::question("Disable Lock?");   // this doesn't block other events, so after return everything might be messed up.

   899                 RDEBUG("value", value);

   900                 if (!value)

   901                     errorInProcess = KErrCancel;

   902                 }

   903             if (errorInProcess == KErrNone)

   904                 {

   905                 setLockDialog(aReason, 0); // hide temporarilly because AskValidSecCode doesn't get in top of the Lock-icon. Thus, dismiss it.

   906                 RDEBUG("calling AskValidSecCode", 0);

   907                 errorInProcess = AskValidSecCode(ELockAppDisableDevicelock);

   908                 RDEBUG("errorInProcess", errorInProcess);

   909                 }

   910             if (errorInProcess == KErrNone)

   911                 {

   912                 setLabelIcon( ELockNotActive);

   913                 updateIndicator(ELockNotActive);

   914                 setLockDialog(aReason, 0);

   915                 publishStatus(ELockNotActive);

   916                 }

   917             if (errorInProcess != KErrNone)

   918                 { // re-lock. For example, if password is wrong

   919                 if (iLockStatus >= EDevicelockActive) // this skips the case "unlocking although it wasn't locked"

   920                     setLockDialog(ELockAppEnableDevicelock, 1);

   921                 }

   922             // this never shows a note

   923             }

   924             break;

   925         case ELockAppOfferKeyguard: // 5

   926             {

   927             errorInProcess = CheckIfLegal(ret);

   928             DebugError(errorInProcess);

   929             if (errorInProcess == KErrNone)

   930                 {

   931                 // no need to dismiss screensaver, because it's not active

   932                 // what about any PIN-query, i.e. from settings ? In this case, the query will show after the PIN query is finished. somehow this is good because PIN is more important

   933                 bool value = HbDeviceMessageBox::question("Enable Keyguard?"); // this doesn't block other events, so after return everything might be messed up.

   934                 // what about a nice icon?

   935                 RDEBUG("value", value);

   936                 if (!value)

   937                     errorInProcess = KErrCancel;

   938                 }

   939             if (errorInProcess == KErrNone)

   940                 {

   941                 errorInProcess = TryChangeStatus(ELockAppEnableKeyguard);

   942                 }

   943             // this never shows a note

   944             }

   945             break;

   946         case ELockAppOfferDevicelock: // 6

   947             {

   948             errorInProcess = CheckIfLegal(ret);

   949             DebugError(errorInProcess);

   950             if (errorInProcess == KErrNone)

   951                 {

   952                 setLockDialog(aReason, 0); // hide temporarilly because AskValidSecCode doesn't get in top of the Lock-icon. Thus, dismiss it.

   953                 errorInProcess = AskValidSecCode(ELockAppEnableDevicelock);

   954                 }

   955             if (errorInProcess == KErrNone)

   956                 {

   957                 RDEBUG("ELockAppOfferDevicelock calling ELockAppEnableDevicelock", ELockAppEnableDevicelock);

   958                 errorInProcess = TryChangeStatus(ELockAppEnableDevicelock);

   959                 }

   960             // this never shows a note. Perhaps ELockAppEnableDevicelock does.

   961             }

   962             break;

   963         case ELockAppShowKeysLockedNote: // 7

   964             {

   965             errorInProcess = CheckIfLegal(ret); // it will not be legal if the keyguard is not enabled and the devicelock is not enabled.

   966             DebugError(errorInProcess);

   967             if (errorInProcess == KErrNone)

   968                 {

   969                 iShowKeyguardNote = 1; // this is not sent as parameter, so we need to fake it: ON

   970                 showNoteIfRequested( EKeyguardActive);

   971                 }

   972             }

   973             break;

   974         default:

   975             {

   976             RDEBUG("default", ret);

   977             errorInProcess = KErrNotSupported;

   978             }

   979             break;

   980 

   981         }

   982     return errorInProcess;

   983     }

   984 /**************************/

   985 int Autolock::setLockDialog(int aReason, int status)

   986     {

   987     RDEBUG("aReason", aReason);

   988     RDEBUG("status", status);

   989     RDEBUG("iDeviceDialogCreated", iDeviceDialogCreated);

   990     TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized);

   991     TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);

   992     RDEBUG("err", err);

   993     RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);

   994 

   995     RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();

   996 

   997     if (status == 0) // hide

   998         {

   999         // aReason is not important here, but let's check nevertheless

  1000         RDEBUG("ReleaseContext", R_AVKON_DEFAULT_SKEY_LIST);

  1001         static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->ReleaseContext();

  1002         RDEBUG("PopContext", 0x90);

  1003         static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->PopContext();

  1004         RDEBUG("ReleaseContext done", 0x92);

  1005 

  1006         if (aReason != ELockAppDisableKeyguard && aReason != ELockAppDisableDevicelock)

  1007             {

  1008             RDEBUG("!!!!****!!!!! error. status=0 but aReason", aReason);

  1009             }

  1010         // secUiOriginatedQuery should be ESecurityUIsSystemLockOriginated . If not, this is not correctly setting it

  1011         if (iDeviceDialogCreated >= EDeviceDialogCreated)

  1012             {

  1013             iDeviceDialogCreated = EDeviceDialogDestroyed;

  1014             RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

  1015 

  1016             RDEBUG("calling switchScreensaverMode", ESnsrViewTypeDisabled);

  1017             switchScreensaverMode( ESnsrViewTypeDisabled);

  1018 

  1019             disconnect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), this, SLOT(handleMessageFromScreensaver(QVariantMap)));

  1020             disconnect(iDeviceDialog, SIGNAL(deviceDialogClosed()), this, SLOT(handleScreensaverClosed()));

  1021             RDEBUG("signal disconnected", err);

  1022             // TODO this crashes for EDeviceDialogScreenSaver

  1023             err = iDeviceDialog->cancel();

  1024             RDEBUG("cancel (bool: 1= wellCancelled) err", err);

  1025             err = iDeviceDialog->error();

  1026             RDEBUG("err", err);

  1027             RDEBUG("calling iDeviceDialog->waitForClosed()", 0);

  1028             err = iDeviceDialog->waitForClosed();

  1029             RDEBUG("cancel (bool: 1= well waitForClosed) err", err);

  1030             err = iDeviceDialog->error();

  1031             RDEBUG("err", err);

  1032 

  1033             TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginatedUninitialized);

  1034             RDEBUG("reset KSecurityUIsSecUIOriginatedQuery. err", err);

  1035             // Cancel power key and application key capturing

  1036             groupWin.CancelCaptureKey(mPowerKeyCaptureHandle);

  1037             groupWin.CancelCaptureKey(mApplicationKeyCaptureHandle);

  1038             groupWin.CancelCaptureLongKey(mApplicationLongKeyCaptureHandle);

  1039             RDEBUG("done CancelCaptureKey", 1);

  1040             if (mEKeyYesCaptureHandle)

  1041                 {

  1042                 RDEBUG("mEKeyYesCaptureHandle", mEKeyYesCaptureHandle);

  1043                 groupWin.CancelCaptureKey(mEKeyYesCaptureHandle);

  1044                 mEKeyYesCaptureHandle = NULL;

  1045                 }

  1046             if (mEKeyNoCaptureHandle)

  1047                 {

  1048                 RDEBUG("mEKeyNoCaptureHandle", mEKeyNoCaptureHandle);

  1049                 groupWin.CancelCaptureKey(mEKeyNoCaptureHandle);

  1050                 mEKeyNoCaptureHandle = NULL;

  1051                 }

  1052 

  1053             RDEBUG("deleting iDeviceDialog", 0);

  1054             delete iDeviceDialog;

  1055             RDEBUG("deleted iDeviceDialog", 1);

  1056             iDeviceDialog = NULL;

  1057             }

  1058         }

  1059     else if (status == 1) // show

  1060         {

  1061         RDEBUG("PushContextL", R_AVKON_DEFAULT_SKEY_LIST);

  1062         static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->PushContextL(R_AVKON_SILENT_SKEY_LIST);

  1063         RDEBUG("BringToForeground", 0x90);

  1064         static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->BringToForeground();

  1065         RDEBUG("LockContext", 0x91);

  1066         static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->LockContext();

  1067         RDEBUG("PushContextL Done", 0x92);

  1068 

  1069         // secUiOriginatedQuery should be ESecurityUIsSecUIOriginatedUninitialized . If not, the validation is not correctly filtering it

  1070         QVariantMap params;

  1071         TBool err;

  1072 #define ESecUiTypeDeviceLock        0x00100000

  1073 #define ESecUiTypeKeyguard          0x00200000

  1074 

  1075         if (aReason == ELockAppEnableKeyguard)

  1076             params.insert("type", ESecUiTypeKeyguard);

  1077         else if (aReason == ELockAppEnableDevicelock)

  1078             params.insert("type", ESecUiTypeDeviceLock);

  1079         else

  1080             {

  1081             RDEBUG("error. status=1 but aReason", aReason);

  1082             }

  1083         // no need for title. Icon should be explicit enough

  1084         // params.insert("title", "Locked");

  1085         if (iDeviceDialogCreated < EDeviceDialogCreated)

  1086             {

  1087             if (iDeviceDialog != NULL)

  1088                 {

  1089                 RDEBUG("!!!!!!*********!!!!!!!! error: iDeviceDialog != NULL", 0);

  1090                 }

  1091             RDEBUG("creating iDeviceDialog", 0);

  1092             iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);

  1093             // in theory this is needed only for screensaver, not for LockIcon. But it doesn't harm

  1094             connect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), SLOT(handleMessageFromScreensaver(QVariantMap)));

  1095             connect(iDeviceDialog, SIGNAL(deviceDialogClosed()), SLOT(handleScreensaverClosed()));

  1096             iDeviceDialogCreated = EDeviceDialogCreated;

  1097             RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

  1098             }

  1099         else

  1100             {

  1101             RDEBUG("raising iDeviceDialog", 0);

  1102             // confirm that dialog is present

  1103             err = iDeviceDialog->error();

  1104             RDEBUG("err", err);

  1105             iDeviceDialogCreated = EDeviceDialogRaised;

  1106             RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

  1107             }

  1108         const QString KScreensaverDeviceDialog("com.nokia.screensaver.snsrdevicedialogplugin/1.0");

  1109         RDEBUG("pre show", aReason);

  1110         bool launchSuccesful = iDeviceDialog->show(KScreensaverDeviceDialog, params); // and continue processing

  1111         RDEBUG("post show. bool launchSuccesful", launchSuccesful);

  1112         err = iDeviceDialog->error();

  1113         RDEBUG("iDeviceDialog->error", err);

  1114         if (launchSuccesful) // TODO && !error ???

  1115             {

  1116             iDeviceDialogCreated = EDeviceDialogScreenSaver;

  1117             RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

  1118             // TODO this is needed if creating dialog for first time? switchScreensaverToActiveMode(); // this is needed in case the dialog was existing.

  1119             // Start standy mode timer. The initial state may already be the standby

  1120             // mode but setting screensaver again to standby doesn't hurt.

  1121             mScreensaverModeTimer->start();

  1122             }

  1123         else // some err. Usually 3 (not existing)

  1124             {

  1125             // screensaver has failed. Probably because it's not installed. Then, try the standard lock-icon

  1126             iDeviceDialogCreated = EDeviceDialogLockIcon;

  1127             RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

  1128             const QString KSecQueryUiDeviceDialog("com.nokia.secuinotificationdialog/1.0");

  1129             err = iDeviceDialog->show(KSecQueryUiDeviceDialog, params); // and continue processing

  1130             RDEBUG("post show. err", err);

  1131             }

  1132         err = iDeviceDialog->error();

  1133         RDEBUG("err", err);

  1134         // This won't be needed when screensaver is in place, as the dialogs will be different, and therefore both can be present