--- a/securitydialogs/Autolock/src/Autolock.cpp Thu Oct 07 14:07:34 2010 +0300
+++ b/securitydialogs/Autolock/src/Autolock.cpp Thu Oct 14 13:56:11 2010 +0300
@@ -1,39 +1,29 @@
/*
-* 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"
+ * 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 <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>
@@ -46,28 +36,22 @@
#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 <settingsinternalcrkeys.h> // CenRep keys
#include <w32std.h>
#include <eikenv.h>
+#include <aknsoundsystem.h>
#include <secuisecuritysettings.h>
#include <secui.h>
#include <secuisecurityhandler.h>
#include <etelmm.h>
#include <rmmcustomapi.h>
-
+#include <keylockpolicyapi.h>
#include <qvaluespacesubscriber.h>
+#include <SCPClient.h>
#include <hwrmlightdomaincrkeys.h>
#include <ProfileEngineSDKCRKeys.h>
@@ -76,90 +60,107 @@
#include "../PubSub/securityuisprivatepskeys.h"
#include <avkondomainpskeys.h>
#include <hwrmdomainpskeys.h>
+#include <ctsydomainpskeys.h>
+
+#include <startupdomainpskeys.h>
#include <hbdevicedialog.h>
+// handled now directly but screensaver
+// #include <power_save_display_mode.h>
const TInt KPhoneIndex(0);
const TInt KTriesToConnectServer(2);
const TInt KTimeBeforeRetryingServerConnection(50000);
-
-#define ESecUiTypeLock 0x00100000
-
+#define ESecUiTypeDeviceLock 0x00100000
+#define ESecUiTypeKeyguard 0x00200000
_LIT( KMmTsyModuleName, "PhoneTsy");
+// Constant definitions to control screensaver view types
+static const char *KSnsrViewTypeKey = "view_type";
+enum TSnsrViewType
+ {
+ ESnsrViewTypeInitial = 0, // default initial state, depends on the configuration
+ ESnsrViewTypeActive,
+ ESnsrViewTypeStandby,
+ ESnsrViewTypeDisabled,
+ };
+static const char *KSnsrCmdUnlock = "unlock";
+static const char *KSnsrCmdSwitchLights = "switch_lights";
+static const char *KSnsrCmdSwitchLowPower = "switch_low_power";
+
Autolock::Autolock(QWidget *parent, Qt::WFlags f) :
- QWidget(parent, f), mService(NULL)
+ QWidget(parent, f),
+ mService(NULL),
+ mPowerKeyCaptureHandle(0),
+ mApplicationKeyCaptureHandle(0),
+ mApplicationLongKeyCaptureHandle(0),
+ mEKeyDeviceFCaptureHandle(0),
+ mEKeyBellCaptureHandle(0),
+ mEKeyYesCaptureHandle(0),
+ mEKeyNoCaptureHandle(0),
+ iLockCodeQueryInDisplay(false),
+ mScreensaverModeTimer(0)
+
{
RDEBUG("start autolock", 0);
- // The very first thing is to define the properties, so that others can use them.
+ // 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);
+ TInt ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy, writePolicy);
RDEBUG("defined KSecurityUIsSecUIOriginatedQuery", ret);
- ret = RProperty::Define(KPSUidSecurityUIs,
- KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy,
- writePolicy);
+ 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);
+ 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);
+ 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.
- }
- ret = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,
- autolockState); // this might re-set it. That's not bad. It will re-notify all listeners.
+ 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);
+ ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), KWritePolicy);
RDEBUG("defined KAknKeyguardStatus", ret);
- ret = RProperty::Define(KPSUidSecurityUIs,
- KSecurityUIsLockInitiatorUID, RProperty::EInt, readPolicy,
- writePolicy);
+ ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLockInitiatorUID, RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), writePolicy);
RDEBUG("defined KSecurityUIsLockInitiatorUID", ret);
- ret = RProperty::Define(KPSUidSecurityUIs,
- KSecurityUIsLockInitiatorTimeHigh, RProperty::EInt, readPolicy,
- writePolicy);
+ ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, RProperty::EInt, readPolicy, writePolicy);
RDEBUG("defined KSecurityUIsLockInitiatorTimeHigh", ret);
- ret = RProperty::Define(KPSUidSecurityUIs,
- KSecurityUIsLockInitiatorTimeLow, RProperty::EInt, readPolicy,
- writePolicy);
+ 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));
+ 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));
+ 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.
+ // Note: this is fast : 0.02 seconds
+ 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)
- // this is defined.
+ // this is defined.
RDEBUG( "Q_WS_S60", 1 );
QPalette p = qApp->palette();
QColor color(192,192,192);
@@ -178,8 +179,8 @@
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)
// this doesn't work well
@@ -194,10 +195,14 @@
TInt lightsTimeout = 0;
CRepository* repository = NULL;
TInt cRresult = 0;
+ iLockCodeQueryInDisplay = EFalse;
+ Q_UNUSED(cRresult);
+ TInt err = 0;
+ iProcessingEvent = -1;
iLockStatusPrev = ELockNotActive;
iLockStatus = ELockNotActive;
- QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidSecuritySettings) );
+ QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidSecuritySettings));
cRresult = repository->Get(KSettingsAutolockStatus, lockValue);
RDEBUG("KSettingsAutolockStatus", KSettingsAutolockStatus);
RDEBUG("cRresult", cRresult);
@@ -208,91 +213,113 @@
adjustInactivityTimers(0);
- QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidProfileEngine) );
+ QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidProfileEngine));
cRresult = repository->Get(KProEngActiveProfile, lightsTimeout);
// this value is not used for now
delete repository;
- QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidLightSettings) );
+ QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidLightSettings));
cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout);
// this value is not used for now
delete repository;
// 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()));
+ subscriberKSettingsAutolockStatus = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutolockStatus", this);
+ err = connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutolockStatusChanged()));
+ RDEBUG("err", err);
+ subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutoLockTime", this);
+ err = connect(subscriberKSettingsAutoLockTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutoLockTimeChanged()));
+ RDEBUG("err", err);
+ subscriberKSettingsAutomaticKeyguardTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime", this);
+ err = connect(subscriberKSettingsAutomaticKeyguardTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutomaticKeyguardTimeChanged()));
+ RDEBUG("err", err);
+ subscriberKDisplayLightsTimeout = new QValueSpaceSubscriber("/KCRUidLightSettings/KDisplayLightsTimeout", this);
+ err = connect(subscriberKDisplayLightsTimeout, SIGNAL(contentsChanged()), this, SLOT(subscriberKDisplayLightsTimeoutChanged()));
+ RDEBUG("err", err);
+ subscriberKProEngActiveProfile = new QValueSpaceSubscriber("/KCRUidProfileEngine/KProEngActiveProfile", this);
+ err = connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this, SLOT(subscriberKProEngActiveProfileChanged()));
+ RDEBUG("err", err);
+
+ subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this);
+ err = connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));
+ RDEBUG("err", err);
// subscribe to environment changes
- subscriberKHWRMGripStatus = new QValueSpaceSubscriber(
- "/KPSUidHWRM/KHWRMGripStatus");
- connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this,
- SLOT(subscriberKHWRMGripStatusChanged()));
+ subscriberKHWRMGripStatus = new QValueSpaceSubscriber("/KPSUidHWRM/KHWRMGripStatus", this);
+ err = connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKHWRMGripStatusChanged()));
+ RDEBUG("err", err);
+
+ subscriberKAknKeyguardStatus = new QValueSpaceSubscriber("/KPSUidAvkonDomain/KAknKeyguardStatus", this);
+ err = connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKAknKeyguardStatusChanged()));
+ RDEBUG("err", err);
- subscriberKAknKeyguardStatus = new QValueSpaceSubscriber(
- "/KPSUidAvkonDomain/KAknKeyguardStatus");
- connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this,
- SLOT(subscriberKAknKeyguardStatusChanged()));
+ subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber("/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus", this);
+ err = connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));
+ RDEBUG("err", err);
- subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber(
- "/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus");
- connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this,
- SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));
+ subscriberKCTsyCallState = new QValueSpaceSubscriber("/KPSUidCtsyCallInformation/KCTsyCallState", this);
+ err = connect(subscriberKCTsyCallState, SIGNAL(contentsChanged()), this, SLOT(subscriberKCTsyCallStateChanged()));
+ RDEBUG("err", err);
+ subscriberKSecurityUIsTestCode = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsTestCode", this);
+ err = connect(subscriberKSecurityUIsTestCode, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsTestCodeChanged()));
+ RDEBUG("err", err);
// 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()));
+ 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);
+ // if I want to release, I should do: mKeyCaptureHandle = env->RootWin().CaptureKey(EKeyBackspace, 0, 0);
+ mEKeyDeviceFCaptureHandle = groupWin.CaptureKey(EKeyDeviceF, 0, 0);
+ RDEBUG("mEKeyDeviceFCaptureHandle", mEKeyDeviceFCaptureHandle);
+ mEKeyBellCaptureHandle = groupWin.CaptureKey(EKeyBell, 0, 0);
+ RDEBUG("mEKeyBellCaptureHandle", mEKeyBellCaptureHandle);
RDEBUG("got mKeyCaptureHandle", 1);
+ iTempDisableOnlyKeyguardBecauseIncomingCall=0;
+
iSecQueryUiCreated = -1;
- iDeviceDialogCreated = -1;
- // TODO for now, always starts unlocked
+ setDeviceDialogStatus( EDeviceDialogUninitialized );
+ iDeviceDialog = NULL;
+ // for now, always starts unlocked. This is correct because if locked, the unlock-query (from starter) is on top
// TryChangeStatus(iLockStatus);
TryChangeStatus( ELockNotActive);
lower();
hide();
- // not needed: new AutolockService(this);
+
+ iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);
+ connect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), SLOT(handleMessageFromScreensaver(QVariantMap)), Qt::QueuedConnection); // Qt::QueuedConnection needed to avoid deadlock at waitForClosed
+ connect(iDeviceDialog, SIGNAL(deviceDialogClosed()), SLOT(handleScreensaverClosed()));
+
+ // screensaver standby mode timer
+ mScreensaverModeTimer = new QTimer(this);
+ mScreensaverModeTimer->setInterval(5 * 1000); // milliseconds, TODO: read from cenrep
+ connect(mScreensaverModeTimer, SIGNAL(timeout()), SLOT(switchScreensaverToPowerSaveMode()));
+ // screensaver AMOLED low power mode support
+
+ // handled now directly but screensaver
+ // mScreensaverPowerSave = CPowerSaveDisplayMode::NewL();
+ // mScreensaverPowerSavePixelBuffer = HBufC16::NewL(360 * 640);
+ // mScreensaverPowerSavePixelBuffer->Des().Fill(0);
+ RDEBUG("99", 0x99);
}
+// destructor
Autolock::~Autolock()
{
RDEBUG("0", 0);
delete mService;
+ // handled now directly but screensaver
+ // delete mScreensaverPowerSave;
+ // delete mScreensaverPowerSavePixelBuffer;
+ RDEBUG("99", 0x99);
}
+// when detected some settings change, syncronize all of them
void Autolock::adjustInactivityTimers(int aReason)
{
RDEBUG("aReason", aReason);
@@ -300,46 +327,100 @@
TInt lockTime = 0;
CRepository* repository = NULL;
TInt cRresult = 0;
+ Q_UNUSED(cRresult);
- QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidSecuritySettings) );
- cRresult = repository->Get(KSettingsAutomaticKeyguardTime, keyguardTime); // in seconds
+ 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)
+ if (keyguardTime > 2 && keyguardTime < 24 * 60 * 60) // limit it to 1 day
{
serviceKeyguard->setInactivityPeriod(keyguardTime);
}
else
{
- serviceKeyguard->setInactivityPeriod(12 * 31 * 24 * 60 * 60);
+ serviceKeyguard->setInactivityPeriod(12 * 31 * 24 * 60 * 60); // if not set, fake it to 1 year
}
- cRresult = repository->Get(KSettingsAutoLockTime, lockTime); // in minutes, handled internally as seconds
+ 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
+ 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 keyguard, to avoid keyguard->devicelock sequence
+ if(lockTime<=2)
+ lockTime=2;
+ RDEBUG("new lockTime", lockTime);
+ }
+ if (lockTime >= 2 && lockTime < 24 * 60 * 60) // lock timer can't be bigger than 1 day
{
+ RDEBUG("setInactivityPeriod lockTime", lockTime);
serviceDevicelock->setInactivityPeriod(lockTime);
}
else
{
- serviceDevicelock->setInactivityPeriod(12 * 31 * 24 * 60 * 60); // 0x1ea6e00
+ RDEBUG("setInactivityPeriod infinite", lockTime);
+ serviceDevicelock->setInactivityPeriod(12 * 31 * 24 * 60 * 60); // 0x1ea6e00 = 1 year
}
+ delete repository;
+ RDEBUG("99", 0x99);
+ }
- delete repository;
- }
+// Some external says to quit. It should not happen, but it helps to validate memory leaks
void Autolock::quit()
{
RDEBUG("0", 0);
qApp->quit();
}
+// Inform P&S listeners thatthe screensaver is created/hidden/dismissed . In particular, HbDeviceDialogs needs this to display other pending notes.
+int Autolock::setDeviceDialogStatus(int aStatus)
+ {
+ RDEBUG("aStatus", aStatus);
+ RDEBUG("prev iDeviceDialogStatus", iDeviceDialogStatus);
+ TInt lPSStatus;
+ TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsScreenSaverStatus, lPSStatus);
+ RDEBUG("err", err);
+ RDEBUG("lPSStatus", lPSStatus);
+ if(aStatus>=EDeviceDialogLastValue)
+ {
+ RDEBUG("EDeviceDialogLastValue exceeded by aStatus", aStatus);
+ }
+ else
+ {
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsScreenSaverStatus, aStatus);
+ iDeviceDialogStatus = aStatus;
+ RDEBUG("err", err);
+ }
+ return aStatus;
+ }
+// 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);
+ RDEBUG("aCaller", aCaller);
+ TInt err = 0;
+ if(aMode!=ESecurityUIsLightsLockOffRequest && aMode!=ELockAppDisableKeyguard)
+ {
+ RDEBUG("KLightsSSForcedLightsOn", KLightsSSForcedLightsOn);
+ err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, 30);
+ }
+ else
+ {
+ RDEBUG("skip KLightsSSForcedLightsOn because aMode", aMode);
+ }
+ RDEBUG("err", err);
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, aMode);
+ RDEBUG("KSecurityUIsLights err", err);
+ return err;
+ }
+
+// When locked, ask for the code. Returns KErrNone or KErrCancel. In other words: this keeps asking until correct code.
int Autolock::AskValidSecCode(int aReason)
{
RDEBUG("aReason", aReason);
@@ -349,19 +430,16 @@
return KErrNone;
#endif
-
TInt err(KErrGeneral);
+ Q_UNUSED(err);
TBool validCode(EFalse);
TInt thisTry(0);
RTelServer iTelServer;
- err = RProperty::Set(KPSUidSecurityUIs,
- KSecurityUIsLights, ESecurityUIsLightsQueryOnRequest);
- RDEBUG("KSecurityUIsLights err", err);
+ TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x10);
RMmCustomAPI iCustomPhone;
- while ((err = iTelServer.Connect()) != KErrNone && (thisTry++)
- <= KTriesToConnectServer)
+ while ((err = iTelServer.Connect()) != KErrNone && (thisTry++) <= KTriesToConnectServer)
{
User::After( KTimeBeforeRetryingServerConnection);
}
@@ -382,18 +460,18 @@
if (aReason == ELockAppDisableDevicelock)
{
RDEBUG("calling AskSecCodeInAutoLockL", 0);
- QT_TRAP_THROWING( validCode = handler->AskSecCodeInAutoLockL() ); // this returns true/false
+ iLockCodeQueryInDisplay = ETrue;
+ QT_TRAP_THROWING(validCode = handler->AskSecCodeInAutoLockL()); // this returns true/false
+ iLockCodeQueryInDisplay = EFalse;
// 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::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;
RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);
- RMobilePhone::TMobilePhoneLockSetting lockChange(
- RMobilePhone::ELockSetDisabled);
+ RMobilePhone::TMobilePhoneLockSetting lockChange(RMobilePhone::ELockSetDisabled);
TRequestStatus status = KRequestPending;
TInt ret = KErrNone;
RDEBUG("GetLockInfo", 0);
@@ -403,7 +481,7 @@
ret = status.Int();
RDEBUG("WaitForRequest ret", ret);
#ifdef __WINS__
- if(ret==KErrTimedOut)
+ if (ret == KErrTimedOut)
{
ret = KErrNone;
lockInfo.iSetting = RMobilePhone::ELockSetDisabled; // ask password only if there's no timeout.
@@ -430,11 +508,11 @@
#else
RDEBUG("! OLD_METHOD", 0);
CWait *iWait = NULL;
- QT_TRAP_THROWING( iWait = CWait::NewL() );
+ 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() );
+ QT_TRAP_THROWING(ret = iWait->WaitForRequestL());
RDEBUG("WaitForRequestL ret", ret);
if (iWait)
{
@@ -451,8 +529,8 @@
RDEBUG("WaitForRequestL ret", ret);
#ifdef __WINS__
- if(ret==KErrTimedOut)
- ret = KErrNone;
+ if (ret == KErrTimedOut)
+ ret = KErrNone;
#endif
if (ret == KErrNone)
validCode = 1;
@@ -460,145 +538,184 @@
validCode = 0;
}
else
- {
- RDEBUG("RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);
- RDEBUG("lockInfo.iSetting = RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);
+ {
+ 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
+ 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)
+ if (validCode > 0)
return KErrNone;
- // no valid code -> switch off the lights
- err = RProperty::Set(KPSUidSecurityUIs,
- KSecurityUIsLights, ESecurityUIsLightsLockOffRequest);
- RDEBUG("KSecurityUIsLights err", err);
+ // no valid code -> switch off the lights
+ TurnLights(ESecurityUIsLightsLockOffRequest, aReason, 0x12);
return KErrCancel;
}
+// The API client might inform that it got our answer. Nothing to do.
void Autolock::handleAnswerDelivered()
{
RDEBUG("0", 0);
// quit();
}
-
+// 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);
}
+// Used on debug environment for printing the Request in understandable format
void Autolock::DebugRequest(int aReason)
{
switch (aReason)
{
case ELockAppEnableKeyguard:
- RDEBUG("ELockAppEnableKeyguard", aReason);
+ RDEBUG("ELockAppEnableKeyguard", aReason)
+ ;
break;
case ELockAppDisableKeyguard:
- RDEBUG("ELockAppDisableKeyguard", aReason);
+ RDEBUG("ELockAppDisableKeyguard", aReason)
+ ;
break;
case ELockAppEnableDevicelock:
- RDEBUG("ELockAppEnableDevicelock", aReason);
+ RDEBUG("ELockAppEnableDevicelock", aReason)
+ ;
break;
case ELockAppDisableDevicelock:
- RDEBUG("ELockAppDisableDevicelock", aReason);
+ RDEBUG("ELockAppDisableDevicelock", aReason)
+ ;
break;
case ELockAppOfferKeyguard:
- RDEBUG("ELockAppOfferKeyguard", aReason);
+ RDEBUG("ELockAppOfferKeyguard", aReason)
+ ;
break;
case ELockAppOfferDevicelock:
- RDEBUG("ELockAppOfferDevicelock", aReason);
+ RDEBUG("ELockAppOfferDevicelock", aReason)
+ ;
break;
case ELockAppShowKeysLockedNote:
- RDEBUG("ELockAppShowKeysLockedNote", aReason);
+ RDEBUG("ELockAppShowKeysLockedNote", aReason)
+ ;
break;
default:
- RDEBUG("default", aReason);
+ RDEBUG("default", aReason)
+ ;
break;
}
}
+// Used on debug environment for printing the Status in understandable format
void Autolock::DebugStatus(int aReason)
{
switch (aReason)
{
case ELockNotActive:
- RDEBUG("ELockNotActive", aReason);
+ RDEBUG("ELockNotActive", aReason)
+ ;
break;
case EKeyguardActive:
- RDEBUG("EKeyguardActive", aReason);
+ RDEBUG("EKeyguardActive", aReason)
+ ;
break;
case EDevicelockActive:
- RDEBUG("EDevicelockActive", aReason);
+ RDEBUG("EDevicelockActive", aReason)
+ ;
break;
default:
- RDEBUG("default", aReason);
+ RDEBUG("default", aReason)
+ ;
break;
}
}
+// Used on debug environment for printing the Error in understandable format
void Autolock::DebugError(int aReason)
{
switch (aReason)
{
case KErrNone:
- RDEBUG("KErrNone", aReason);
+ RDEBUG("KErrNone", aReason)
+ ;
break;
- case KErrPermissionDenied: // caller doesn't have enough capabilities
- RDEBUG("KErrPermissionDenied", aReason);
+ case KErrPermissionDenied: // caller doesn't have enough capabilities
+ RDEBUG("KErrPermissionDenied", aReason)
+ ;
break;
- case KErrAlreadyExists: // this particular lock is already enabled
- RDEBUG("KErrAlreadyExists", aReason);
+ case KErrAlreadyExists: // this particular lock is already enabled
+ RDEBUG("KErrAlreadyExists", aReason)
+ ;
break;
- case KErrInUse: // the dialog is already shown
- RDEBUG("KErrInUse", aReason);
+ case KErrInUse: // the dialog is already shown
+ RDEBUG("KErrInUse", aReason)
+ ;
+ break;
+ case KErrLocked: // never happens
+ RDEBUG("KErrLocked", aReason)
+ ;
break;
default:
- RDEBUG("default", aReason);
+ RDEBUG("default", aReason)
+ ;
break;
}
}
-
+// Check whether the future status is valid.
+// Typical reasons for failure include: not correct status for this operation, lack of capabilities.
+// Note that other things are handled in specific places: Active call, grip open, query on top
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)
+ // 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)
TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized);
- TInt err = RProperty::Get(KPSUidSecurityUIs,
- KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);
+ TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);
RDEBUG("err", err);
RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);
+
+ TInt startupValue(EStartupUiPhaseUninitialized);
+ err = RProperty::Get(KPSUidStartup, KPSStartupUiPhase, startupValue);
+ RDEBUG("err", err);
+ RDEBUG("startupValue", startupValue);
+
+ TInt simStatusValue(0);
+ err = RProperty::Get(KPSUidStartup, KPSSimStatus, simStatusValue);
+ RDEBUG("err", err);
+ RDEBUG("simStatusValue", simStatusValue);
+ if(startupValue<EStartupUiPhaseAllDone && aReason!=ELockAppDisableKeyguard && aReason!=ELockAppDisableDevicelock )
+ {
+ // before bootup, it can't be manually nor automatically keyguarded/locked
+ RDEBUG("before bootup, it can't be manually nor automatically keyguarded/locked KErrInUse", KErrInUse);
+ return KErrInUse;
+ }
+
switch (aReason)
{
case ELockAppEnableKeyguard:
{
RDEBUG("ELockAppEnableKeyguard iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized)
+ if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized)
return KErrInUse; // PIN on top. Don't keyguard
switch (iLockStatus)
{
case ELockNotActive:
- if (1 == 0) // !CKeyLockPolicyApi::KeyguardAllowed() )
+ if (!CKeyLockPolicyApi::KeyguardAllowed())
return KErrPermissionDenied;
else
return KErrNone;
@@ -627,10 +744,7 @@
case ELockAppEnableDevicelock:
{
RDEBUG("ELockAppEnableDevicelock iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized
- && secUiOriginatedQuery
- != ESecurityUIsSystemLockOriginated)
+ if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)
return KErrInUse; // PIN on top. Don't devicelock
switch (iLockStatus)
{
@@ -646,12 +760,12 @@
case ELockAppDisableDevicelock:
{
RDEBUG("ELockAppDisableDevicelock iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized
- && secUiOriginatedQuery
- != ESecurityUIsSystemLockOriginated)
+ if (iLockCodeQueryInDisplay)
{
// PIN on top and trying to display unlock-code. This is valid
+ // but needs to turn on lights because SysAp switches them off even if query is present
+ TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x13);
+ return KErrAlreadyExists;
}
switch (iLockStatus)
{
@@ -667,10 +781,7 @@
case ELockAppOfferKeyguard:
{
RDEBUG("ELockAppOfferKeyguard iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized
- && secUiOriginatedQuery
- != ESecurityUIsSystemLockOriginated)
+ if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)
return KErrInUse; // PIN on top. Don't offer
switch (iLockStatus)
{
@@ -686,10 +797,7 @@
case ELockAppOfferDevicelock:
{
RDEBUG("ELockAppOfferDevicelock iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized
- && secUiOriginatedQuery
- != ESecurityUIsSystemLockOriginated)
+ if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)
return KErrInUse; // PIN on top. Don't offer
switch (iLockStatus)
{
@@ -705,10 +813,7 @@
case ELockAppShowKeysLockedNote:
{
RDEBUG("ELockAppShowKeysLockedNote iLockStatus", iLockStatus);
- if (secUiOriginatedQuery
- != ESecurityUIsSecUIOriginatedUninitialized
- && secUiOriginatedQuery
- != ESecurityUIsSystemLockOriginated)
+ if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized && secUiOriginatedQuery != ESecurityUIsSystemLockOriginated)
return KErrInUse; // PIN on top. Don't display
switch (iLockStatus)
{
@@ -716,7 +821,7 @@
return KErrPermissionDenied;
case EKeyguardActive:
return KErrNone;
- case EDevicelockActive:
+ case EDevicelockActive: // TODO confirm this. CMMKeyBearer::ReceivedKeyEvent expects KErrNone if keypad is locked
return KErrPermissionDenied;
}
}
@@ -731,32 +836,51 @@
return KErrPermissionDenied;
}
+// After a succesful status change, communicate it to the world, using P&S and CenRep
int Autolock::publishStatus(int aReason)
{
RDEBUG("aReason", aReason);
- TInt err;
+ Q_UNUSED(aReason);
+ TInt err = KErrNone;
+ Q_UNUSED(err);
// can't use include file because it's private file. However it gives permissions
- const TUid KCRUidCoreApplicationUIsSysAp = { 0x101F8765 };
+ 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) );
+ QT_TRAP_THROWING(repositoryDevicelock = CRepository::NewL(KCRUidSecuritySettings));
+ QT_TRAP_THROWING(repositoryKeyguard = CRepository::NewL(KCRUidCoreApplicationUIsSysAp));
TInt cRresult = KErrNone;
+ Q_UNUSED(cRresult);
+
+ TInt autolockState;
+ err = RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState);
+ RDEBUG("Get KCoreAppUIsAutolockStatus", err);
+ RDEBUG("autolockState", autolockState);
+
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);
+ err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardNotActive);
RDEBUG("err", err);
- err = RProperty::Set(KPSUidCoreApplicationUIs,
- KCoreAppUIsAutolockStatus, EAutolockOff);
- RDEBUG("err", err);
- // lights are required ?
+ if(autolockState!=EAutolockOff)
+ {
+ err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
+ RDEBUG("err", err);
+ }
+ else
+ {
+ RDEBUG("not set KCoreAppUIsAutolockStatus because already ", 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
+ // 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);
}
@@ -764,30 +888,36 @@
{
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);
+ err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardLocked);
+ RDEBUG("KAknKeyguardStatus err", err);
+ if(autolockState!=EAutolockOff)
+ {
+ err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);
+ RDEBUG("KCoreAppUIsAutolockStatus err", err);
+ }
+ else
+ {
+ RDEBUG("not set KCoreAppUIsAutolockStatus because already ", EAutolockOff);
+ }
+ TurnLights(ESecurityUIsLightsLockOffRequest, aReason, 0x16); // same for keyguard and devicelock
// 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);
+ err = RProperty::Set(KPSUidAvkonDomain, KAknKeyguardStatus, EKeyguardLocked); // previously EKeyguardAutolockEmulation, but then Telephone doesn't understand that it's keyguarded. Other candidates might be: EKeyguardLocked and EKeyguardNotActive
+ RDEBUG("KAknKeyguardStatus err", err);
+ if(autolockState!=EManualLocked)
+ {
+ err = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EManualLocked);
+ RDEBUG("KCoreAppUIsAutolockStatus err", err);
+ }
+ else
+ {
+ RDEBUG("not set KCoreAppUIsAutolockStatus because already ", 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);
@@ -802,11 +932,16 @@
RDEBUG("setting iLockStatus", iLockStatus);
return KErrNone;
}
-/********************/
+// Shows a note. This is used from the API to inform about actions. The side-switch-key and the automatic lock will not show notes.
int Autolock::showNoteIfRequested(int aReason)
{
RDEBUG("aReason", aReason);
-
+ // The notes are displayed. This is useful only for the API withNote, and ELockAppShowKeysLockedNote
+ // However, it has some inconvenients:
+ // - the screensaver already displays/hides
+ // - the notes are shown behing the icon because they have lower priorities
+ // - they are annoying
+ // TODO translate
if (aReason == ELockNotActive)
{
if (iShowKeyguardNote == 1)
@@ -819,6 +954,7 @@
if (iShowKeyguardNote == 1)
{
HbDeviceMessageBox::information("Keyguard activated");
+ // this already waits a bit because the lock-icon takes some time to display. So the note is visible before the lock-icon.
}
}
else if (aReason >= EDevicelockActive) // this doesn't happen, but we are prepared nevertheless
@@ -830,7 +966,9 @@
}
return KErrNone;
}
-/***********************/
+// Does the logic and actions for changing status.
+// This is the main function of this program.
+// On every status, the process is the same: continue with next step only if previous one is successful.
int Autolock::TryChangeStatus(int aReason)
{
RDEBUG("aReason", aReason);
@@ -838,10 +976,13 @@
int errorInProcess = KErrNone;
DebugRequest(ret);
- TInt err = RProperty::Set(KPSUidSecurityUIs,
- KSecurityUIsDismissDialog,
- ESecurityUIsDismissDialogOn);
- RDEBUG("err", err);
+ TInt err = KErrNone;
+ Q_UNUSED(err);
+ // this will NOT cancel any previous dialog, i.e. PIN query, or any previous code-request.
+ // not sure about the screensaver, but nevertheless will be cancelled when the status is changed.
+ RDEBUG("Not setting KSecurityUIsDismissDialog ESecurityUIsDismissDialogOn", ESecurityUIsDismissDialogOn);
+ //// err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogOn);
+ RDEBUG("err", err);
switch (ret)
{
case ELockAppEnableKeyguard: // 1
@@ -850,11 +991,20 @@
DebugError(errorInProcess);
if (errorInProcess == KErrNone)
{
- setLabelIcon( EKeyguardActive);
+ showNoteIfRequested( EKeyguardActive);
+ setLabelIcon(EKeyguardActive);
updateIndicator(EKeyguardActive);
publishStatus(EKeyguardActive);
- showNoteIfRequested(EKeyguardActive);
+ setLockDialog(aReason, EDeviceDialogCreated);
}
+ // Telephone might want to re-enable only-keyguard after the call ends. Allow it. This means re-showing the screensaver, not more.
+ // Note: this is already done in CallStateChanged, so it's useless. Therefore it expects KErrLocked, which never happens
+ if (errorInProcess == KErrLocked && iTempDisableOnlyKeyguardBecauseIncomingCall==1)
+ {
+ RDEBUG("allowing telephone to re-enable keyguard . Call setLockDialog EDeviceDialogScreenSaverReDisplay", EDeviceDialogScreenSaverReDisplay);
+ setLockDialog(aReason, EDeviceDialogScreenSaverReDisplay);
+ iTempDisableOnlyKeyguardBecauseIncomingCall=0;
+ }
}
break;
case ELockAppDisableKeyguard: // 2
@@ -863,12 +1013,30 @@
DebugError(errorInProcess);
if (errorInProcess == KErrNone)
{
- setLabelIcon( ELockNotActive);
+ showNoteIfRequested( ELockNotActive);
+ setLabelIcon(ELockNotActive);
updateIndicator(ELockNotActive);
publishStatus(ELockNotActive);
- showNoteIfRequested(ELockNotActive);
+ setLockDialog(aReason, EDeviceDialogDestroyed);
}
}
+ RDEBUG("errorInProcess", errorInProcess);
+ // Telephone might want to disable only-keyguard during a call. Allow it. This means hiding the screensaver, not more.
+ // Note: this is already done in CallStateChanged, so it's useless. Therefore it expects KErrLocked, which never happens
+ if(errorInProcess==KErrLocked)
+ {
+ TInt aCallStatus=-1;
+ TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, aCallStatus);
+ RDEBUG("err", err);
+ RDEBUG("aCallStatus", aCallStatus);
+ if (aCallStatus != EPSCTsyCallStateUninitialized && aCallStatus != EPSCTsyCallStateNone)
+ {
+ RDEBUG("allowing telephone to disable keyguard . Call setLockDialog EDeviceDialogScreenSaverHidden", EDeviceDialogScreenSaverHidden);
+ setLockDialog(aReason, EDeviceDialogScreenSaverHidden);
+ iTempDisableOnlyKeyguardBecauseIncomingCall=1;
+ errorInProcess=KErrNone;
+ }
+ }
break;
case ELockAppEnableDevicelock: // 3
{
@@ -885,7 +1053,7 @@
updateIndicator( EDevicelockActive);
publishStatus(EDevicelockActive);
setLabelIcon(EDevicelockActive);
- setLockDialog(aReason, 1);
+ setLockDialog(aReason, EDeviceDialogCreated);
}
// aParam1 is aReason : EDevicelockManual, EDevicelockRemote
// this never shows a note
@@ -903,30 +1071,54 @@
}
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("skip setLockDialog", 0);
+ // No need to disable screensaver. Notes now can get on top. Also, this avoids the transition Screensaver->unlockQuery, which produces flicker on HomeScreen.
+ setLockDialog(aReason, EDeviceDialogScreenSaverHidden); // Hide temporarilly because HbDeviceMessageBox doesn't get in top of the Lock-icon. Thus, dismiss it.
+ // do I need to enable touch? it seems to work without it
+ // in any case, lights are needed
+ TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x20);
+ bool value = true;
+ // not sure whether this question is really needed. The UI doesn't say anything, so I remove it for now.
+ RDEBUG("not calling HbDeviceMessageBox::question", 0);
+ // 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("skip setLockDialog", 0);
+ // No need to disable screensaver. Notes now can get on top. Also, this avoids the transition Screensaver->unlockQuery, which produces flicker on HomeScreen.
+ setLockDialog(aReason, EDeviceDialogScreenSaverHidden); // 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)
{
+ // code is correct. Time to destroy the lock-icon
setLabelIcon( ELockNotActive);
updateIndicator(ELockNotActive);
+ setLockDialog(aReason, EDeviceDialogDestroyed);
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);
+ else // errorInProcess != KErrNone
+ { // re-lock. For example, if password is cancelled. Remember that this applies also for the case KErrPermissionDenied
+ TInt aCallStatus=-1;
+ TInt skipScreenSaver=0;
+ TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, aCallStatus);
+ RDEBUG("err", err);
+ RDEBUG("aCallStatus", aCallStatus);
+ if (aCallStatus != EPSCTsyCallStateUninitialized && aCallStatus != EPSCTsyCallStateNone)
+ {
+ // if there's an active call and the query is cancelled, screensaver should not show.
+ skipScreenSaver=1; // if it's skipped, it will be set at CallStateChanged
+ RDEBUG("new skipScreenSaver", skipScreenSaver);
+ }
+ RDEBUG("skipScreenSaver", skipScreenSaver);
+ if (iLockStatus >= EDevicelockActive) // this skips the case "unlocking although it wasn't locked"
+ if(!skipScreenSaver)
+ setLockDialog(ELockAppEnableDevicelock, EDeviceDialogScreenSaverReDisplay);
}
// this never shows a note
}
@@ -937,14 +1129,20 @@
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?
+ // no need to dismiss screensaver, because it's not active
+ // 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
+ bool value = HbDeviceMessageBox::question("Enable Keyguard?"); // this doesn't block other events, so after return everything might be messed up i.e. the time-out might have triggered.
+ // what about a nice icon?
RDEBUG("value", value);
if (!value)
errorInProcess = KErrCancel;
}
if (errorInProcess == KErrNone)
{
+ errorInProcess = CheckIfLegal(ret); // confirm that it's still possible to do it. For example, if API did a lock
+ }
+ if (errorInProcess == KErrNone)
+ {
errorInProcess = TryChangeStatus(ELockAppEnableKeyguard);
}
// this never shows a note
@@ -956,9 +1154,11 @@
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);
- }
+ RDEBUG("skip setLockDialog", 0);
+ // No need to disable screensaver. Notes now can get on top. Also, this avoids the transition Screensaver->unlockQuery, which produces flicker on HomeScreen.
+ setLockDialog(aReason, EDeviceDialogScreenSaverHidden); // 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);
@@ -967,75 +1167,150 @@
// this never shows a note. Perhaps ELockAppEnableDevicelock does.
}
break;
- case ELockAppShowKeysLockedNote: // 7
+ case ELockAppShowKeysLockedNote: // 7
{
- errorInProcess = CheckIfLegal(ret); // it will not be legal if the keyguard is not enabled and the devicelock is not enabled.
+ 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);
- }
+ showNoteIfRequested( EKeyguardActive);
+ }
}
break;
default:
+ {
RDEBUG("default", ret);
errorInProcess = KErrNotSupported;
+ }
break;
}
+ RDEBUG("errorInProcess", errorInProcess);
return errorInProcess;
}
-/**************************/
-int Autolock::setLockDialog(int aReason, int status)
+// Shows or hides the Screensaver/LockIcon
+int Autolock::setLockDialog(int aReason, int target)
{
RDEBUG("aReason", aReason);
- RDEBUG("status", status);
- RDEBUG("iDeviceDialogCreated", iDeviceDialogCreated);
+ RDEBUG("target", target);
+ RDEBUG("iDeviceDialogStatus", iDeviceDialogStatus);
TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized);
- TInt err = RProperty::Get(KPSUidSecurityUIs,
- KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);
+ TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);
RDEBUG("err", err);
RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);
- if (status == 0) // hide
+ RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();
+
+ if (target == EDeviceDialogDestroyed || target == EDeviceDialogScreenSaverHidden) // hide
{
+ 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);
+ }
// secUiOriginatedQuery should be ESecurityUIsSystemLockOriginated . If not, this is not correctly setting it
- if (iDeviceDialogCreated > 0)
+ if (iDeviceDialogStatus >= EDeviceDialogCreated)
{
- iDeviceDialogCreated = 0;
- iDeviceDialog->cancel();
- err = iDeviceDialog->error();
- RDEBUG("err", err);
- TInt err = RProperty::Set(KPSUidSecurityUIs,
- KSecurityUIsSecUIOriginatedQuery,
- ESecurityUIsSecUIOriginatedUninitialized);
- RDEBUG("err", err);
+ if(mScreensaverModeTimer)
+ {
+ RDEBUG("mScreensaverModeTimer->stop()", 0);
+ mScreensaverModeTimer->stop();
+ }
+ if(target == EDeviceDialogDestroyed)
+ {
+ disconnect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), this, SLOT(handleMessageFromScreensaver(QVariantMap)));
+ disconnect(iDeviceDialog, SIGNAL(deviceDialogClosed()), this, SLOT(handleScreensaverClosed()));
+ RDEBUG("signal disconnected", err);
+ // TODO this used to crash for EDeviceDialogScreenSaver. Not anymore.
+ err = iDeviceDialog->cancel();
+ RDEBUG("cancel (bool: 1= wellCancelled) err", err);
+ err = iDeviceDialog->error();
+ RDEBUG("err", err);
+ RDEBUG("calling iDeviceDialog->waitForClosed()", 0);
+ err = iDeviceDialog->waitForClosed();
+ RDEBUG("cancel (bool: 1= well waitForClosed) err", err);
+ err = iDeviceDialog->error();
+ RDEBUG("err", err);
+ handleScreensaverClosed();
+ RDEBUG("deleting iDeviceDialog", 0);
+ delete iDeviceDialog;
+ RDEBUG("deleted iDeviceDialog", 1);
+ iDeviceDialog = NULL;
+ }
+ else if(target == EDeviceDialogScreenSaverHidden)
+ {
+ RDEBUG("calling switchScreensaverMode", ESnsrViewTypeDisabled);
+ switchScreensaverMode( ESnsrViewTypeDisabled);
+ }
+
+ TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginatedUninitialized);
+ RDEBUG("reset KSecurityUIsSecUIOriginatedQuery. err", err);
+
+ // Lights will be on by SysAp when screen is un-keyguarded
+ // TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x22); // let's bring light into HomeScreen
+ // Cancel power key and application key capturing
+ groupWin.CancelCaptureKey(mPowerKeyCaptureHandle);
+ groupWin.CancelCaptureKey(mApplicationKeyCaptureHandle);
+ groupWin.CancelCaptureLongKey(mApplicationLongKeyCaptureHandle);
+ RDEBUG("done CancelCaptureKey", 1);
+ if (mEKeyYesCaptureHandle)
+ {
+ RDEBUG("mEKeyYesCaptureHandle", mEKeyYesCaptureHandle);
+ groupWin.CancelCaptureKey(mEKeyYesCaptureHandle);
+ mEKeyYesCaptureHandle = NULL;
+ }
+ if (mEKeyNoCaptureHandle)
+ {
+ RDEBUG("mEKeyNoCaptureHandle", mEKeyNoCaptureHandle);
+ groupWin.CancelCaptureKey(mEKeyNoCaptureHandle);
+ mEKeyNoCaptureHandle = NULL;
+ }
+ setDeviceDialogStatus( target );
}
}
- else if (status == 1) // show
+ else if (target == EDeviceDialogCreated || target == EDeviceDialogScreenSaverReDisplay) // show
{
+ 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;
-#define ESecUiTypeDeviceLock 0x00100000
-#define ESecUiTypeKeyguard 0x00200000
+ TBool err=EFalse;
- if (aReason == EKeyguardActive)
+ if (aReason == ELockAppEnableKeyguard)
params.insert("type", ESecUiTypeKeyguard);
- else if (aReason >= EDevicelockActive)
+ else if (aReason == ELockAppEnableDevicelock)
params.insert("type", ESecUiTypeDeviceLock);
else
{
- RDEBUG("error. status=1 but aReason", aReason);
+ RDEBUG("!!!!****!!!!! error. target=1 but aReason", aReason);
}
// no need for title. Icon should be explicit enough
// params.insert("title", "Locked");
- if (iDeviceDialogCreated <= 0)
+ if (iDeviceDialogStatus < EDeviceDialogCreated)
{
+ if (iDeviceDialog != NULL)
+ {
+ RDEBUG("!!!!!!*********!!!!!!!! error: iDeviceDialog != NULL", 0);
+ }
RDEBUG("creating iDeviceDialog", 0);
iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);
- iDeviceDialogCreated = 1;
+ // in theory this is needed only for screensaver, not for LockIcon. But it doesn't harm
+ connect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), SLOT(handleMessageFromScreensaver(QVariantMap)), Qt::QueuedConnection); // Qt::QueuedConnection needed to avoid deadlock at waitForClosed
+ connect(iDeviceDialog, SIGNAL(deviceDialogClosed()), SLOT(handleScreensaverClosed()));
+ setDeviceDialogStatus(EDeviceDialogCreated);
}
else
{
@@ -1043,42 +1318,91 @@
// confirm that dialog is present
err = iDeviceDialog->error();
RDEBUG("err", err);
- iDeviceDialogCreated = 2;
+ setDeviceDialogStatus( EDeviceDialogRaised );
}
- const QString KSecQueryUiDeviceDialog("com.nokia.secuinotificationdialog/1.0");
+ const QString KScreensaverDeviceDialog("com.nokia.screensaver.snsrdevicedialogplugin/1.0");
RDEBUG("pre show", aReason);
- err = iDeviceDialog->show(KSecQueryUiDeviceDialog, params); // and continue processing
- RDEBUG("post show. err", err);
+ TInt skipScreenSaver=0;
+ bool launchSuccesful = EFalse;
+
+ TInt aCallStatus=-1;
+ err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, aCallStatus);
+ RDEBUG("aCallStatus", aCallStatus);
+ // never create screensaver if active call.
+ if (aCallStatus != EPSCTsyCallStateUninitialized && aCallStatus != EPSCTsyCallStateNone && iLockStatus >= EDevicelockActive )
+ {
+ skipScreenSaver=1;
+ RDEBUG("new skipScreenSaver", skipScreenSaver);
+ }
+ RDEBUG("skipScreenSaver", skipScreenSaver);
+ if(!skipScreenSaver)
+ {
+ if(iDeviceDialogStatus == EDeviceDialogCreated)
+ {
+ launchSuccesful = iDeviceDialog->show(KScreensaverDeviceDialog, params); // and continue processing
+ RDEBUG("post show. bool launchSuccesful", launchSuccesful);
+ }
+ else if(iDeviceDialogStatus == EDeviceDialogScreenSaverHidden || iDeviceDialogStatus == EDeviceDialogRaised)
+ {
+ RDEBUG("calling switchScreensaverMode ESnsrViewTypeActive", ESnsrViewTypeActive);
+ switchScreensaverMode( ESnsrViewTypeActive);
+ launchSuccesful = ETrue;
+ }
+ }
+ RDEBUG("bool launchSuccesful", launchSuccesful);
+ err = iDeviceDialog->error();
+ RDEBUG("iDeviceDialog->error", err);
+ if (launchSuccesful) // TODO && !error ???
+ {
+ setDeviceDialogStatus( EDeviceDialogScreenSaver );
+ // TODO this is needed if creating dialog for first time? switchScreensaverToActiveMode(); // this is needed in case the dialog was existing.
+ // Start standy mode timer. The initial state may already be the standby
+ // mode but setting screensaver again to standby doesn't hurt.
+ mScreensaverModeTimer->start();
+ }
+ else if (!skipScreenSaver)// some err. Usually 3 (component not existing)
+ {
+ // screensaver has failed. Probably because it's not installed. Then, try the standard lock-icon
+ setDeviceDialogStatus( EDeviceDialogLockIcon );
+ const QString KSecQueryUiDeviceDialog("com.nokia.secuinotificationdialog/1.0");
+ 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 ?
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginatedUninitialized); // this could also be ESecurityUIsSystemLockOriginated
RDEBUG("err", err);
-
+ // Capture power and application keys while screen saver is open. Also works for LockIcon
+ mPowerKeyCaptureHandle = groupWin.CaptureKey(EKeyDevice2, 0, 0);
+ mApplicationKeyCaptureHandle = groupWin.CaptureKey(EKeyApplication0, 0, 0);
+ mApplicationLongKeyCaptureHandle = groupWin.CaptureLongKey(EKeyApplication0, EKeyApplication0, 0, 0, 0, ELongCaptureShortEventImmediately | ELongCaptureRepeatEvents);
+ mEKeyYesCaptureHandle = groupWin.CaptureKey(EKeyYes, 0, 0);
+ mEKeyNoCaptureHandle = groupWin.CaptureKey(EKeyNo, 0, 0);
+ RDEBUG("keys captured", err);
}
else
{
- RDEBUG("unknown status", status);
+ RDEBUG("unknown target", target);
return KErrNotSupported;
}
return KErrNone;
}
+// Updates the icon. This is not used anymore
void Autolock::setLabelIcon(int aReason)
{
RDEBUG("aReason", aReason);
if (aReason == ELockNotActive)
{
- setLockDialog(aReason, 0); // TODO isn't this done already at TryChangeStatus ???
+ // setLockDialog(aReason, 0); // This is done already at TryChangeStatus
lower();
hide();
}
else if (aReason == EKeyguardActive)
{
- setLockDialog(aReason, 1);
+ // setLockDialog(aReason, 1); // This is done already at TryChangeStatus
// this shows the Autolock Application. not needed
}
else if (aReason == EDevicelockActive)
@@ -1089,7 +1413,7 @@
RDEBUG("error: aReason", aReason);
}
}
-
+// Update idicator in HomeScreen. This is a small key icon in the top-left
int Autolock::updateIndicator(int aReason)
{
RDEBUG("aReason", aReason);
@@ -1101,135 +1425,347 @@
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
+ 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");
+ 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
+ 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;
}
-
+// activity while keyguarded.
void Autolock::activeKeyguard()
{
- // activity while keyguarded. Nothing to do
RDEBUG("0", 0);
+ // Nothing to do
+ RDEBUG("99", 0x99);
}
+// inactivity. Keyguard should be activated
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);
+ TInt callState = EPSCTsyCallStateNone;
+ int err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);
+ RDEBUG("err", err);
+ RDEBUG("callState", callState);
+ // if there's an active call, don't auto-keyguard (manual is still possible)
+ if (callState <= EPSCTsyCallStateNone)
+ {
+ ret = TryChangeStatus(ELockAppEnableKeyguard);
+ RDEBUG("ret", ret);
+ }
+ else
+ {
+ RDEBUG("not ELockAppEnableKeyguard because callState", callState);
+ }
+ }
+ else
+ {
+ // restart screensaver. The scenario is: keyguard->screensaver->CriticalNote->lightsOn . Therefore we need lightsOff
+ // this is done when keyguard can't be enabled because it's already enabled
+ // Note that this happens only once, so it's fine to show the screensaver in full light.
+ if (ret == KErrAlreadyExists) // this could also be iLockStatus == EKeyguardActive
+ switchScreensaverMode( ESnsrViewTypeInitial);
+ }
+ RDEBUG("ret", ret);
+ }
+// Some activity detected while the deviceLock is enabled
+void Autolock::activeDevicelock()
+ {
+ RDEBUG("0", 0);
+ // nothing to do
+ RDEBUG("99", 0x99);
+ }
+
+// inactivity. Devicelock should be activated
+void Autolock::notActiveDevicelock()
+ {
+ RDEBUG("0", 0);
+ int ret = KErrNone;
+ Q_UNUSED(ret);
+ DebugStatus( iLockStatus);
+ if (iLockStatus == ELockNotActive || iLockStatus == EKeyguardActive) // not possible if it's locked
+ {
+ // this is independent of the call status
+ ret = TryChangeStatus(ELockAppEnableDevicelock);
}
RDEBUG("ret", ret);
}
-/* Some activity detected while the deviceLock is enabled */
-void Autolock::activeDevicelock()
+// Update the screensaver. Show, hide, or sleep
+void Autolock::switchScreensaverMode(int mode)
{
- // nothing to do
+ RDEBUG("mode", mode);
+ if (iDeviceDialog)
+ {
+ // maybe this can be used to tell the dialog to dismiss itself?
+ RDEBUG("got iDeviceDialog. iDeviceDialogStatus", iDeviceDialogStatus);
+ QVariantMap params;
+ // this is for LockIcon. Doesn't harm screensaver
+ // need to send again so that the existing dialog still knows what is its type
+ if (iLockStatus == EKeyguardActive)
+ params.insert("type", ESecUiTypeKeyguard);
+ else if (iLockStatus >= EDevicelockActive)
+ params.insert("type", ESecUiTypeDeviceLock);
+
+ // this is for screensaver. Doesn't harm LockIcon
+ params.insert(KSnsrViewTypeKey, mode);
+ iDeviceDialog->update(params);
+
+ if (mScreensaverModeTimer)
+ {
+ if (mode == ESnsrViewTypeStandby || mode == ESnsrViewTypeDisabled)
+ {
+ RDEBUG("stop mScreensaverModeTimer", 0);
+ mScreensaverModeTimer->stop();
+ }
+ else
+ {
+ RDEBUG("start mScreensaverModeTimer", 0);
+ mScreensaverModeTimer->start();
+ }
+ }
+ }
+ RDEBUG("99", 0x99);
+ }
+
+void Autolock::switchScreensaverToPowerSaveMode()
+ {
RDEBUG("0", 0);
+ // This crashes IVE3. TODO : restore when it works again.
+ //switchScreensaverMode( ESnsrViewTypeStandby);
+ RDEBUG("99", 0x99);
}
-void Autolock::notActiveDevicelock()
+void Autolock::handleMessageFromScreensaver(const QVariantMap &data)
{
- // inactivity. Devicelock should be activated
RDEBUG("0", 0);
- int ret = KErrNone;
- DebugStatus( iLockStatus);
- if (iLockStatus == ELockNotActive || iLockStatus == EKeyguardActive) // not possible if it's locked
+ RDEBUG("iLockStatus", iLockStatus);
+ QVariantMap::const_iterator it = data.find(KSnsrCmdUnlock);
+ if (it != data.end() && iLockStatus != ELockNotActive)
+ {
+ RDEBUG("calling handleLockSwitch", 0);
+ handleLockSwitch();
+ }
+
+ it = data.find(KSnsrCmdSwitchLights);
+ if (it != data.end())
+ {
+ int lightStatus = it.value().toInt();
+ RDEBUG("switching screen lights . lightStatus", lightStatus);
+ int err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, lightStatus);
+ RDEBUG("err", err);
+ }
+
+ it = data.find(KSnsrCmdSwitchLowPower);
+ if (it != data.end())
{
- ret = TryChangeStatus(ELockAppEnableDevicelock);
+ QVariantList lowPowerLimits = it.value().toList();
+ if (lowPowerLimits.count() == 2)
+ {
+ // switch on screen power save mode when start and end lines are given
+ int startRow = lowPowerLimits.at(0).toInt();
+ int endRow = lowPowerLimits.at(1).toInt();
+ // TODO: The pixel buffer passed to CPowerSaveDisplayMode is supposed to
+ // contain the pixels shown in the active area of the screen. Currently, we
+ // pass a buffer filled with 0s, and this works fine on the reference
+ // hardware. However, according to display driver people, this doesn't
+ // work if the display component of the device doesn't have internal memory
+ // which may be the case in some of our target devices.
+
+ // handled now directly by screensaver
+ /*
+ TUint16 *ptr = const_cast<TUint16 *> (mScreensaverPowerSavePixelBuffer->Ptr());
+ RDEBUG("switching screen power save on, number of visible rows", endRow-startRow);
+ int err = mScreensaverPowerSave->Set(startRow, endRow, ptr);
+ RDEBUG("err", err);
+ */
+ }
+ else
+ {
+ // any other case is interpreted as an order to switch off the power save and
+ // return to the normal mode
+ RDEBUG("switching screen power save off 0", 0);
+ // handled now directly by screensaver
+ // int err = mScreensaverPowerSave->Exit();
+ // RDEBUG("err", err);
+ }
}
- RDEBUG("ret", ret);
+ RDEBUG("99", 0x99);
+ }
+
+void Autolock::handleScreensaverClosed()
+ {
+ RDEBUG("0", 0);
+ int err(0);
+ // 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
+ /*
+ if (mScreensaverPowerSave)
+ {
+ RDEBUG("switching screen power save off", 0);
+ err = mScreensaverPowerSave->Exit();
+ RDEBUG("error=", err);
+ }
+ */
+ RDEBUG("switching screen lights on", 1);
+ // Not needed because SysAp turns on the lights when keyguard is disabled
+ // err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, 30);
+ RDEBUG("err", err);
}
// some key is pressed
+// TODO perhaps need a way to stop switch-key while asking unlock-code?
+// Not clear what to do here. dismiss query?
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)
+ if (ev->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *> (ev);
RDEBUG("KeyPress", keyEvent->key());
RDEBUG("KeyPress nativeScanCode", keyEvent->nativeScanCode());
RDEBUG("EStdKeyDeviceF", EStdKeyDeviceF);
+ RDEBUG("EKeyDeviceF", EKeyDeviceF);
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)
- }
- }
- }
+ // note that the key was EKeyApplication0 and EKeyDevice2
+ // yes=0xc4 app=0xb4 no=0xa6
+ if (keyEvent->nativeScanCode() == EStdKeyApplication0 || keyEvent->nativeScanCode() == EStdKeyDevice2 || keyEvent->nativeScanCode() == EStdKeyYes
+ || keyEvent->nativeScanCode() == EStdKeyNo)
+ {
+ // switch to active screensaver if application key or power key pressed while screensaver active
+ // This key can be repeated, so that the screensaver remains as long as key is pushed
+ // TODO what happens when holding Power key ?
+ switchScreensaverMode( ESnsrViewTypeActive);
+ TurnLights(ESecurityUIsLightsQueryOnRequest, 0x22 /*aReason*/, 0x24);
+ }
+ else if (!keyEvent->isAutoRepeat())
+ {
+ if (keyEvent->key() == EKeyInsert)
+ {
+ // on WINS, this is handled with the "Ins" key in the numeric keypad
+ RDEBUG("EKeyInsert", EKeyInsert);
+ // only reacts on release, not on press
+ isSwitchKey = 1;
+ }
+ else if (keyEvent->key() == EKeyDeviceF)
+ {
+ // this never seem to happen. Nevertheless we are not doing anything
+ RDEBUG("EKeyDeviceF", EKeyDeviceF);
+ }
+ else if (keyEvent->nativeScanCode() == EStdKeyDeviceF)
+ {
+ RDEBUG("got EStdKeyDeviceF", EStdKeyDeviceF);
+ isSwitchKey = 1;
+ }
+ else if (keyEvent->nativeScanCode() == EKeyBell) // this might be sent by others, i.e. PCFW
+ {
+ RDEBUG("got EKeyBell", EKeyBell);
+ isSwitchKey = 1;
+ }
+ else if (keyEvent->key() == 0x1ffffff)
+ {
+ RDEBUG("0x1ffffff", 0x1ffffff); // some unknown key is received. Nothing to do
+ }
+ }
+ }
+ 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);
+ handleLockSwitch();
+ RDEBUG("0", 0);
} // isSwitchKey
} // ev
// Process if not done before. For example, redraw or quit
- return QWidget::event(ev);
+ TBool widgetEventSuccesful = QWidget::event(ev);
+ RDEBUG("99", 0x99);
+ return widgetEventSuccesful;
+ }
+// The side-switch-key is pressed. Un-keyguard if keyguarded ; AskCode if locked.
+int Autolock::handleLockSwitch()
+ {
+ RDEBUG("0", 0);
+ int ret = KErrNone;
+ RDEBUG("iProcessingEvent", iProcessingEvent);
+ RDEBUG("iLockStatus", iLockStatus);
+ // iProcessingEvent is used to avoid concurrent processing, i.e. 2 side-switch presses; because it needs time to create (and dismiss) the dialog
+ // However this disallows keyguard during unlock-quey.
+ if(iProcessingEvent < 1)
+ {
+ iProcessingEvent = 1;
+ Q_UNUSED(ret);
+ DebugStatus( iLockStatus);
+ if (iLockStatus == ELockNotActive)
+ {
+ iShowKeyguardNote = 0; // no note on enable keyguard
+ callerHasECapabilityWriteDeviceData = 1;
+ // TODO ELockAppEnableDevicelock
+ CRepository *repository = 0;
+ int deviceLock = 0;
+ QT_TRAP_THROWING(repository = CRepository::NewL(KCRUidSecuritySettings));
+ repository->Get(KSettingsAutoLockTime, deviceLock);
+ delete repository;
+ if (65535 == deviceLock) {
+ // Setting says "When keys& screen locked". Therefore device is also locked when screen is manually locked.
+ // TODO what about the API for screen lock?
+ ret = TryChangeStatus(ELockAppEnableDevicelock); // this should not ask confirmation
+ } else {
+ ret = TryChangeStatus(ELockAppEnableKeyguard); // this should not ask confirmation
+ }
+
+ }
+ else if (iLockStatus == EKeyguardActive)
+ {
+ iShowKeyguardNote = 0; // no note on disable keyguard
+ callerHasECapabilityWriteDeviceData = 1;
+ ret = TryChangeStatus(ELockAppDisableKeyguard);
+ }
+ else if (iLockStatus == EDevicelockActive)
+ {
+ callerHasECapabilityWriteDeviceData = 1;
+ ret = TryChangeStatus(ELockAppDisableDevicelock);
+ }
+ else
+ {
+ RDEBUG("unknown iLockStatus", iLockStatus);
+ }
+ iProcessingEvent = 0;
+ }
+ else
+ {
+ // user presses side-switch while another is in process, most probably a unlock-query. Thus, re-switch on the lights
+ iProcessingEvent++; // just to know how many processes we missed
+ if(iProcessingEvent>=10)
+ iProcessingEvent=0; // if user really insists, then try again
+ if (iLockStatus == EDevicelockActive)
+ {
+ TurnLights(ESecurityUIsLightsQueryOnRequest, ELockAppEnableDevicelock, 0x26);
+ }
+ }
+ RDEBUG("ret", ret);
+ return ret;
}
bool Autolock::eventFilter(QObject *o, QEvent *ev)
@@ -1242,88 +1778,157 @@
void Autolock::subscriberKSettingsAutolockStatusChanged()
{
RDEBUG("0", 0);
- QVariant v = subscriberKSettingsAutolockStatus->value(
- "/KCRUidSecuritySettings/KSettingsAutolockStatus");
+ QVariant v = subscriberKSettingsAutolockStatus->value("/KCRUidSecuritySettings/KSettingsAutolockStatus");
adjustInactivityTimers( KSettingsAutolockStatus);
}
void Autolock::subscriberKSettingsAutoLockTimeChanged()
{
RDEBUG("0", 0);
- QVariant v = subscriberKSettingsAutoLockTime->value(
- "/KCRUidSecuritySettings/KSettingsAutoLockTime");
+ QVariant v = subscriberKSettingsAutoLockTime->value("/KCRUidSecuritySettings/KSettingsAutoLockTime");
adjustInactivityTimers( KSettingsAutoLockTime);
}
void Autolock::subscriberKSettingsAutomaticKeyguardTimeChanged()
{
RDEBUG("0", 0);
- QVariant v = subscriberKSettingsAutomaticKeyguardTime->value(
- "/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime");
+ QVariant v = subscriberKSettingsAutomaticKeyguardTime->value("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime");
adjustInactivityTimers( KSettingsAutoLockTime);
}
void Autolock::subscriberKDisplayLightsTimeoutChanged()
{
RDEBUG("0", 0);
- QVariant v = subscriberKDisplayLightsTimeout->value(
- "/KCRUidLightSettings/KDisplayLightsTimeout");
+ QVariant v = subscriberKDisplayLightsTimeout->value("/KCRUidLightSettings/KDisplayLightsTimeout");
// nothing to do
}
void Autolock::subscriberKProEngActiveProfileChanged()
{
RDEBUG("0", 0);
- QVariant v = subscriberKProEngActiveProfile->value(
- "/KCRUidProfileEngine/KProEngActiveProfile");
+ 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;
+ TInt ret = KErrNone;
+ Q_UNUSED(ret);
RDEBUG("0", 0);
TInt aGripStatus;
- TInt err = RProperty::Get(KPSUidHWRM, KHWRMGripStatus, 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);
- }
- }
+ if (aGripStatus == EPSHWRMGripOpen)
+ {
+ if (iLockStatus == EKeyguardActive)
+ {
+ iShowKeyguardNote = 0; // no note on disable keyguard
+ callerHasECapabilityWriteDeviceData = 1;
+ ret = TryChangeStatus(ELockAppDisableKeyguard);
+ }
+ else if (iLockStatus == EDevicelockActive)
+ {
+ callerHasECapabilityWriteDeviceData = 1;
+ ret = TryChangeStatus(ELockAppDisableDevicelock);
+ }
+ }
+ else if (aGripStatus == EPSHWRMGripClosed)
+ {
+ if (iLockStatus == ELockNotActive)
+ {
+ iShowKeyguardNote = 0; // no note on enable keyguard
+ callerHasECapabilityWriteDeviceData = 1;
+ ret = TryChangeStatus(ELockAppEnableKeyguard);
+ }
+ }
+ RDEBUG("ret", ret);
+ }
+/**************/
+void Autolock::subscriberKCTsyCallStateChanged()
+ {
+ RDEBUG("0", 0);
+ TInt aCallStatus;
+ TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, aCallStatus);
+ RDEBUG("err", err);
+ RDEBUG("aCallStatus", aCallStatus);
+ RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();
+ RDEBUG("iLockStatus", iLockStatus);
+ if (aCallStatus == EPSCTsyCallStateUninitialized || aCallStatus == EPSCTsyCallStateNone)
+ {
+ // Telephone might want to re-enable only-keyguard after the call ends. Allow it. This means re-showing the screensaver, not more.
+ RDEBUG("call is inactive", aCallStatus);
+ if(iLockStatus == EDevicelockActive)
+ setLockDialog(ELockAppEnableKeyguard, 1);
+
+ if (iLockStatus == EKeyguardActive || iLockStatus == EDevicelockActive)
+ {
+ if (!mEKeyYesCaptureHandle)
+ mEKeyYesCaptureHandle = groupWin.CaptureKey(EKeyYes, 0, 0);
+ if (!mEKeyNoCaptureHandle)
+ mEKeyNoCaptureHandle = groupWin.CaptureKey(EKeyNo, 0, 0);
+ }
+ }
+ else
+ {
+ RDEBUG("call is active", aCallStatus);
+
+ RDEBUG("allowing telephone to disable keyguard . Call setLockDialog 0", 0);
+ if(iLockStatus == EDevicelockActive)
+ setLockDialog(ELockAppDisableKeyguard, 0);
+
+ // Telephone should be on top, but nevertheless we give End/Send to them
+ // This should be done only if locked, but it doesn't harm
+ if (mEKeyYesCaptureHandle)
+ {
+ RDEBUG("mEKeyYesCaptureHandle", mEKeyYesCaptureHandle);
+ groupWin.CancelCaptureKey(mEKeyYesCaptureHandle);
+ mEKeyYesCaptureHandle = NULL;
+ }
+ if (mEKeyNoCaptureHandle)
+ {
+ RDEBUG("mEKeyNoCaptureHandle", mEKeyNoCaptureHandle);
+ groupWin.CancelCaptureKey(mEKeyNoCaptureHandle);
+ mEKeyNoCaptureHandle = NULL;
+ }
+ // it seems that Telephone doesn't turn-on the lights when an incoming call on deviceLock. It's done here.
+ TurnLights(ESecurityUIsLightsQueryOnRequest, ELockAppDisableKeyguard, 0x28);
+ }
+ RDEBUG("99", 0x99);
+ }
+// SecUiNotificationDialog::subscriberKSecurityUIsDismissDialogChanged()
+// A way for Autolock to dismiss any possible PIN dialog
+// ----------------------------------------------------------------------------
+//
+void Autolock::subscriberKSecurityUIsDismissDialogChanged()
+ {
+ RDEBUG("0", 0);
+ TInt aDismissDialog = ESecurityUIsDismissDialogUninitialized;
+ TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsDismissDialog, aDismissDialog);
+ RDEBUG("err", err);
+ RDEBUG("aDismissDialog", aDismissDialog);
}
+void Autolock::subscriberKSecurityUIsTestCodeChanged()
+ {
+ RDEBUG("0", 0);
+ TInt aTestCode = -1;
+ TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsTestCode, aTestCode);
+ RDEBUG("err", err);
+ RDEBUG("aTestCode", aTestCode);
+ }
// ----------AutolockService---------------
AutolockService::AutolockService(Autolock* parent) :
- XQServiceProvider(QLatin1String(
- "com.nokia.services.Autolock.Autolock"), parent),
- mAutolock(parent), mAsyncReqId(-1), mAsyncAnswer(false)
+ 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()));
+ connect(this, SIGNAL(returnValueDelivered()), parent, SLOT(handleAnswerDelivered()));
}
AutolockService::~AutolockService()
@@ -1340,8 +1945,7 @@
}
// got API request from lockaccessextension
-int AutolockService::service(const QString& number,
- const QString& aParam1, const QString& aParam2)
+int AutolockService::service(const QString& number, const QString& aParam1, const QString& aParam2)
{
RDEBUG("0", 0);
TInt err = KErrNone;
@@ -1375,22 +1979,32 @@
myTime.HomeTime();
TInt myTimeHigh = 0;
TInt myTimeLow = 0;
- err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh );
+ err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh);
RDEBUG("err", err);
RDEBUG("myTimeHigh", myTimeHigh);
- err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow );
+ 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 );
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeHigh, myTimeHigh);
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorTimeLow, myTimeLow);
ret = mAutolock->TryChangeStatus(ret);
RDEBUG("ret", ret);
+
+ TInt myInitiatorUID = 0;
+ err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsLockInitiatorUID, myInitiatorUID);
+ RDEBUG("ret", ret);
+ RDEBUG("myInitiatorUID", myInitiatorUID);
+ myInitiatorUID = info.clientSecureId();
+ err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLockInitiatorUID, myInitiatorUID);
+ RDEBUG("ret", ret);
+ RDEBUG("myInitiatorUID", myInitiatorUID);
+
return ret;
}
@@ -1399,7 +2013,7 @@
RDEBUG("0", 0);
// Just quit service application if client ends
mAsyncAnswer = false;
- RDEBUG("0", 0);
+ RDEBUG("99", 0x99);
// mAutolock->quit();
}