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

equal deleted inserted replaced

-:989397f9511c
+:67b3e3c1fc87
 #include <HbIndicator>
 #include <hbdevicemessagebox.h>
 #include <lockappclientserver.h>
+#include <centralrepository.h>
 #include "Autolock.h"
 #include <xqserviceutil.h>
 #include "autolockuseractivityservice.h"
 #include <settingsinternalcrkeys.h>     // CenRep keys
 ESnsrViewTypeDisabled,
 };
 static const char *KSnsrCmdUnlock = "unlock";
 static const char *KSnsrCmdSwitchLights = "switch_lights";
 static const char *KSnsrCmdSwitchLowPower = "switch_low_power";
+static const char *KSnsrCmdResetActiveModeTimer = "resetActiveModeTimer";
 Autolock::Autolock(QWidget *parent, Qt::WFlags f) :
 QWidget(parent, f),
 mService(NULL),
 mPowerKeyCaptureHandle(0),
 ret = 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.
+autolockState = EAutolockOff; // not-initialized means that 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);
 ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsDismissDialog, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), TSecurityPolicy(
 TSecurityPolicy::EAlwaysPass));
 RDEBUG("defined KSecurityUIsDismissDialog", ret);
-		// call TARM so that it verifies that configuration is in sync. This might internally accept the (default) lock code, but doesn't dismiss the query.
+ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsScreenSaverStatus, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), writePolicy);
-		// Note: this is fast : 0.02 seconds
+RDEBUG("defined KSecurityUIsScreenSaverStatus", ret);
-		RSCPClient scpClientConfiguration;
-		User::LeaveIfError( scpClientConfiguration.Connect() );
-	  CleanupClosePushL( scpClientConfiguration );
-		RDEBUG("call CheckConfiguration KSCPComplete", KSCPComplete);
-		TInt finalConfStatus = scpClientConfiguration.CheckConfiguration( KSCPComplete );
-		RDEBUG("finalConfStatus", finalConfStatus);
-		CleanupStack::PopAndDestroy();	// scpClientConfiguration
 mService = new AutolockService(this);
 /* Adjust the palette */
-#if defined(Q_WS_S60)
+RDEBUG( "Palette", 1 );
-// 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::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)
 		RDEBUG( "Q_WS_X11", 1 );
 setFixedSize(QSize(360,640)); // nHD
-#elif defined(Q_WS_S60)
+#else
 // this doesn't work well
 // showMaximized();
 showFullScreen();
 #endif
 CRepository* repository = NULL;
 TInt cRresult = 0;
 iLockCodeQueryInDisplay = EFalse;
 Q_UNUSED(cRresult);
 TInt err = 0;
+err = err;
 		iProcessingEvent = -1;
 iLockStatusPrev = ELockNotActive;
 iLockStatus = ELockNotActive;
+iSCPConfigured = 0;
 QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidSecuritySettings));
 cRresult = repository->Get(KSettingsAutolockStatus, lockValue);
 RDEBUG("KSettingsAutolockStatus", KSettingsAutolockStatus);
 RDEBUG("cRresult", cRresult);
 RDEBUG("lockValue", lockValue);
 // when detected some settings change, syncronize all of them
 void Autolock::adjustInactivityTimers(int aReason)
 {
 RDEBUG("aReason", aReason);
+aReason = aReason;
 TInt keyguardTime = 0;
 TInt lockTime = 0;
 CRepository* repository = NULL;
 TInt cRresult = 0;
 Q_UNUSED(cRresult);
 // Adjust the lights. It uses P&S, honoured by SysAp
 int Autolock::TurnLights(int aMode, int aReason, int aCaller)
 {
 RDEBUG("aMode", aMode);
 RDEBUG("aReason", aReason);
+aReason = aReason;
 RDEBUG("aCaller", aCaller);
+aCaller = aCaller;
 TInt err = 0;
 if(aMode!=ESecurityUIsLightsLockOffRequest && aMode!=ELockAppDisableKeyguard)
 	{
 	RDEBUG("KLightsSSForcedLightsOn", KLightsSSForcedLightsOn);
 	err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, 30);
 }
 // This was used when Autolock-debug had a label to display the request. Not in use any more
 void Autolock::setLabelNumber(QString label, QString number)
 {
 RDEBUG("0", 0);
+label = label;
+number = number;
 }
 // Used on debug environment for printing the Request in understandable format
 void Autolock::DebugRequest(int aReason)
 {
 	err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
 	RDEBUG("err", err);
 	}
 else
 	{
-	RDEBUG("not set KCoreAppUIsAutolockStatus because already ", EAutolockOff);
+	RDEBUG("not set KCoreAppUIsAutolockStatus because already EAutolockOff", EAutolockOff);
 	}
 			// Not needed. SysAp turns the lights when keyguard is disabled
 // TurnLights(ESecurityUIsLightsLockOnRequest, aReason, 0x14);
 // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0);    // the settings remains. Only ISA changes, as well as the P&S
 	                err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
 	              RDEBUG("KCoreAppUIsAutolockStatus err", err);
 	            	}
 		            else
 		            	{
-		            	RDEBUG("not set KCoreAppUIsAutolockStatus because already ", EAutolockOff);
+		            	RDEBUG("not set KCoreAppUIsAutolockStatus because already EAutolockOff", EAutolockOff);
 		            	}
 TurnLights(ESecurityUIsLightsLockOffRequest, aReason, 0x16);	// same for keyguard and devicelock
 // cRresult = repositoryDevicelock->Set(KSettingsAutolockStatus, 0);
 cRresult = repositoryKeyguard->Set(KSysApKeyguardActive, 1);
 RDEBUG("cRresult", cRresult);
 	                err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EManualLocked);
 	              RDEBUG("KCoreAppUIsAutolockStatus err", err);
 	            	}
 		            else
 		            	{
-		            	RDEBUG("not set KCoreAppUIsAutolockStatus because already ", EManualLocked);
+		            	RDEBUG("not set KCoreAppUIsAutolockStatus because already EManualLocked", EManualLocked);
 		            	}
 TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x18);
 // 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.
+RDEBUG("iLockStatusPrev", iLockStatusPrev);
 iLockStatusPrev = iLockStatus;
 iLockStatus = aReason;
 RDEBUG("setting iLockStatus", iLockStatus);
 return KErrNone;
 }
 iShowKeyguardNote = 1; // this is not sent as parameter, so we need to fake it: ON
 showNoteIfRequested( EKeyguardActive);
 }
 }
 break;
+case 0x100: // Start/confirm server
+{
+						// call TARM so that it verifies that configuration is in sync. This might internally accept the (default) lock code, but doesn't dismiss the query.
+						// Note: this is fast : 0.02 seconds
+						TInt secuiOperation=mParam1;
+						TInt iStartup=0;	// this comes as a flag, part of secuiOperation
+						iStartup = iStartup;
+						RDEBUG("secuiOperation", secuiOperation);
+						RDEBUG("iSCPConfigured", iSCPConfigured);
+						errorInProcess = KErrNone;
+						if(secuiOperation>=0x1000)
+							{
+							iStartup=1;
+							secuiOperation-=0x1000;
+							}
+						if(secuiOperation==0 /*unknown*/ || secuiOperation==2 /*PIN*/)
+							{
+							// nothing to do. SCP should not be verified on PIN ; only on lock-query at boot
+							RDEBUG("nothing to do because secuiOperation", secuiOperation);
+							RDEBUG("KErrCompletion", KErrCompletion);
+							errorInProcess = KErrCompletion;
+							}
+						else
+							{
+								// usually secuiOperation=6
+							if(!iSCPConfigured)
+								{
+								RSCPClient scpClientConfiguration;
+								User::LeaveIfError( scpClientConfiguration.Connect() );
+							  CleanupClosePushL( scpClientConfiguration );
+								RDEBUG("call CheckConfiguration KSCPComplete", KSCPComplete);
+								TInt finalConfStatus = scpClientConfiguration.CheckConfiguration( KSCPComplete );
+								RDEBUG("finalConfStatus", finalConfStatus);
+								CleanupStack::PopAndDestroy();	// scpClientConfiguration
+								iSCPConfigured=1;
+								errorInProcess = KErrNone;
+								}
+							else
+								{
+								RDEBUG("nothing to do because iSCPConfigured", iSCPConfigured);
+								RDEBUG("KErrAlreadyExists", KErrAlreadyExists);
+								errorInProcess = KErrAlreadyExists;
+								}
+							}
+}
+break;
 default:
 {
 RDEBUG("default", ret);
 errorInProcess = KErrNotSupported;
 }
 RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();
 if (target == EDeviceDialogDestroyed || target == EDeviceDialogScreenSaverHidden) // hide
 {
+/*
+This doesn't work since Avkon deprecations
 RDEBUG("ReleaseContext", R_AVKON_DEFAULT_SKEY_LIST);
 static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->ReleaseContext();
 RDEBUG("PopContext", 0x90);
 static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->PopContext();
 RDEBUG("ReleaseContext done", 0x92);
+*/
 // aReason is not important here, but let's check nevertheless
 if (aReason != ELockAppDisableKeyguard && aReason != ELockAppDisableDevicelock && aReason != ELockAppOfferDevicelock)
 {
 RDEBUG("!!!!****!!!!! error. target=0 but aReason", aReason);
 setDeviceDialogStatus( target );
 }
 }
 else if (target == EDeviceDialogCreated || target == EDeviceDialogScreenSaverReDisplay) // show
 {
+/*
+This doesn't work since Avkon deprecations
 RDEBUG("PushContextL", R_AVKON_DEFAULT_SKEY_LIST);
 static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->PushContextL(R_AVKON_SILENT_SKEY_LIST);
 RDEBUG("BringToForeground", 0x90);
 static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->BringToForeground();
 RDEBUG("LockContext", 0x91);
 static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->KeySounds()->LockContext();
 RDEBUG("PushContextL Done", 0x92);
+*/
 // secUiOriginatedQuery should be ESecurityUIsSecUIOriginatedUninitialized . If not, the validation is not correctly filtering it
 QVariantMap params;
 TBool err=EFalse;
+err = err;
 if (aReason == ELockAppEnableKeyguard)
 params.insert("type", ESecUiTypeKeyguard);
 else if (aReason == ELockAppEnableDevicelock)
 params.insert("type", ESecUiTypeDeviceLock);
 }
 void Autolock::switchScreensaverToPowerSaveMode()
 {
 RDEBUG("0", 0);
-	// This crashes IVE3. TODO : restore when it works again.
+	  // This works again and doesn't crash IVE3
-//switchScreensaverMode( ESnsrViewTypeStandby);
+switchScreensaverMode( ESnsrViewTypeStandby);
 RDEBUG("99", 0x99);
 }
 void Autolock::handleMessageFromScreensaver(const QVariantMap &data)
 {
 {
 int lightStatus = it.value().toInt();
 RDEBUG("switching screen lights . lightStatus", lightStatus);
 int err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, lightStatus);
 RDEBUG("err", err);
+}
+it = data.find(KSnsrCmdResetActiveModeTimer);
+if (it != data.end() && iLockStatus != ELockNotActive)
+{
+RDEBUG("calling switchScreensaverMode ESnsrViewTypeActive", ESnsrViewTypeActive);
+switchScreensaverMode( ESnsrViewTypeActive );
+RDEBUG("done", 1);
 }
 it = data.find(KSnsrCmdSwitchLowPower);
 if (it != data.end())
 {
 void Autolock::handleScreensaverClosed()
 {
 RDEBUG("0", 0);
 int err(0);
+err = err;
 // Screensaver (usually) cannot send anymore any commands when
 // it's being closed. Thus, we need to ensure here that screen has lights and
 // full-power mode once screensaver is closed.
 // handled now directly by screensaver
 // got API request from lockaccessextension
 int AutolockService::service(const QString& number, const QString& aParam1, const QString& aParam2)
 {
 RDEBUG("0", 0);
 TInt err = KErrNone;
+err = err;
 RDEBUG("number", number.toInt());
 RDEBUG("aParam1", aParam1.toInt());
 RDEBUG("aParam2", aParam2.toInt());
 mAsyncAnswer = false;
 XQRequestInfo info = requestInfo();

changeset 66	67b3e3c1fc87
parent 63	989397f9511c