MCL/sf/mw/classicui: comparison uifw/AknGlobalUI/OldStyleNotif/Src/aknkeylocknotifier.cpp

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 /*
-* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <AknUtils.h>
 #include <eikcba.h>
 #include <aknnotecontrol.h>
 #include <aknlayoutscalable_avkon.cdl.h>
-#include <SecondaryDisplay/AknSecondaryDisplayDefs.h>
+#include <secondarydisplay/AknSecondaryDisplayDefs.h>
 #include <avkondomainpskeys.h> // KPSUidAvkonDomain, KAknKeyguardStatus, TAknKeyguardStatus
 #include <startupdomainpskeys.h> // KStartupSecurityCodeQueryStatus
 #include <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus
 #include <AknNotifySignature.h>
 #include "AknCapServerEntry.h"
 #include <aknglobalpopupprioritycontroller.h>
 #include "GlobalWindowPriorities.h"
 #include <keylockpolicyapi.h>
+#include <ScreensaverInternalPSKeys.h>
 #include <PSVariables.h>   // Property values
 #include <coreapplicationuisdomainpskeys.h>
 #include <startupdomainpskeys.h>
 #include <ctsydomainpskeys.h>
 #include <bafindf.h>
 #include "AknNotifyPlugin.hrh"
+#include "akntrace.h"
 #ifdef _DEBUG
 #define TRACES(x)   x
 #else
 _LIT( KRESOURCEFILE, "\\resource\\aknnotpi.rsc" );
 _LIT_SECURITY_POLICY_C1( KWritePolicy, ECapabilityWriteDeviceData );
+/**
+*  CAknKeylockScreenSaverObserver captures primary keys
+*  from screensaver when screen saver is active.
+*
+*  @lib   aknoldstylenotif.lib
+*  @since 3.2
+*/
+NONSHARABLE_CLASS( CAknKeylockScreenSaverObserver ): public CActive
+{
+public:
+/**
+* Creates instance of the CAknKeylockScreenSaverObserver class.
+*
+* @param aWindowGroup application window group used to capture primary keys
+* @return Returns the instance just created.
+*/
+static CAknKeylockScreenSaverObserver* NewL( RWindowGroup& aWindowGroup );
+/**
+* Destructor.
+*/
+~CAknKeylockScreenSaverObserver();
+public:
+/**
+* Starts asynchronic listening KUidCurrentCall event
+*
+* @return KErrNone: if no errors
+* @return KErrInUse: if already listening
+*/
+TInt Start();
+/**
+* Stops asynchronic listening KUidAutolockStatus event
+*/
+void Stop();
+public:
+/**
+*  Method handles the lock state changes.
+*
+* @param aStatus The new lock state
+*/
+void SetLockStatus( TBool aKeylockEnabled, TBool aAutolockEnabled );
+private: // constructors
+/**
+* C++ default constructor.
+*
+* @param aAppUi (pointer to autolock appui)
+*/
+CAknKeylockScreenSaverObserver( RWindowGroup& aWindowGroup );
+/**
+* Symbian OS constructor.
+*/
+void ConstructL();
+private: // from CActive
+/** @see CActive::RunL() */
+void RunL();
+/** @see CActive::DoCancel() */
+void DoCancel();
+private:
+/**
+* Used to capture primary keys defined in keylocking policies
+*/
+void CapturePrimaryKeys( TBool aCapture );
+private: // data
+// screen saver on property
+RProperty  iScreenSaverActiveProperty;
+// if screensaver is active or not
+TBool iScreenSaverActive;
+// if primary keys have been captured
+TBool iCaptured;
+// locking states
+TBool iKeylockEnabled;
+TBool iAutolockEnabled;
+// left softkey capture
+TInt iLeftSoftKey;
+// a reference to application window group
+RWindowGroup& iWindowGroup;
+// keylockpolicy support (not owned)
+CKeyLockPolicyApi* iUnlockPolicyApi;
+// keylockpolicy support (not owned)
+CKeyLockPolicyApi* iDevicelockPolicyApi;
+// primary key captures
+RArray<TUint> iPrimaryKeyCaptures;
+};
+// ===========================================================================
+// class CAknKeylockScreenSaverObserver
+// ===========================================================================
+// ---------------------------------------------------------------------------
+// Constructs a new entry with given values.
+// ---------------------------------------------------------------------------
+//
+CAknKeylockScreenSaverObserver* CAknKeylockScreenSaverObserver::NewL(
+RWindowGroup& aWindowGroup )
+{
+CAknKeylockScreenSaverObserver* self =
+new (ELeave) CAknKeylockScreenSaverObserver( aWindowGroup );
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop( self );
+return self;
+}
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CAknKeylockScreenSaverObserver::~CAknKeylockScreenSaverObserver()
+{
+Cancel();
+// Close the property handle.
+iScreenSaverActiveProperty.Close();
+// Release key captures.
+CapturePrimaryKeys( EFalse );
+// Delete policies.
+delete iUnlockPolicyApi;
+delete iDevicelockPolicyApi;
+}
+// ---------------------------------------------------------------------------
+// Starts listening to the KScreenSaverOn event.
+// ---------------------------------------------------------------------------
+//
+TInt CAknKeylockScreenSaverObserver::Start()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( IsActive() )
+{
+return KErrInUse;
+}
+iStatus = KRequestPending;
+iScreenSaverActiveProperty.Subscribe( iStatus );
+SetActive();
+_AKNTRACE_FUNC_EXIT;
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// Stops listening to the KScreenSaverOn event.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::Stop()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( !IsActive() )
+{
+return;
+}
+Cancel();
+iScreenSaverActiveProperty.Cancel();
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CAknKeylockScreenSaverObserver::CAknKeylockScreenSaverObserver(
+RWindowGroup& aWindowGroup )
+: CActive( 0 ),
+iScreenSaverActive( EFalse ),
+iCaptured( EFalse ),
+iKeylockEnabled( EFalse ),
+iAutolockEnabled( EFalse ),
+iLeftSoftKey( NULL ),
+iWindowGroup( aWindowGroup )
+{
+}
+// ---------------------------------------------------------------------------
+// Second phase constructor.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::ConstructL()
+{
+_AKNTRACE_FUNC_ENTER;
+// Add this active object to the scheduler.
+CActiveScheduler::Add( this );
+User::LeaveIfError( iScreenSaverActiveProperty.Attach( KPSUidScreenSaver,
+KScreenSaverOn ) );
+// We need policies to poll primary keys.
+iUnlockPolicyApi = CKeyLockPolicyApi::NewL( EPolicyDeactivateKeyguard );
+if ( !iUnlockPolicyApi->HasConfiguration() )
+{
+delete iUnlockPolicyApi;
+iUnlockPolicyApi = NULL;
+}
+// we need policies to poll primary keys
+iDevicelockPolicyApi = CKeyLockPolicyApi::NewL( EPolicyDevicelockQuery );
+if ( !iDevicelockPolicyApi->HasConfiguration() )
+{
+delete iDevicelockPolicyApi;
+iDevicelockPolicyApi = NULL;
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// From base class CActive.
+// Handles change in the screen saver state.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::RunL()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( iKeylockEnabled || iAutolockEnabled )
+{
+// Resubscribe before processing new value to prevent missing updates.
+Start();
+}
+TInt screenSaverState;
+iScreenSaverActiveProperty.Get( screenSaverState );
+// Primary keys are captured from screensaver when screensaver
+// is the top most application.
+if ( screenSaverState > NULL )
+{
+__ASSERT_DEBUG( !iCaptured,
+Panic( EAknPanicKeyLockObserverAlreadyExists ) );
+iScreenSaverActive = ETrue;
+CapturePrimaryKeys( ETrue );
+}
+else
+{
+// If screensaver is disabled, stop capturing primary key events.
+if ( iScreenSaverActive )
+{
+CapturePrimaryKeys( EFalse );
+}
+iScreenSaverActive = EFalse;
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// Set the lock status.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::SetLockStatus( TBool aKeylockEnabled,
+TBool aAutolockEnabled )
+{
+_AKNTRACE_FUNC_ENTER;
+iKeylockEnabled  = aKeylockEnabled;
+iAutolockEnabled = aAutolockEnabled;
+if ( iKeylockEnabled || iAutolockEnabled )
+{
+// Start observing screensaver activation.
+Start();
+}
+else
+{
+if ( iScreenSaverActive )
+{
+CapturePrimaryKeys( EFalse );
+}
+// Screensaver is only observed when keylock is enabled.
+Stop();
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// Capture or uncapture primary keys.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::CapturePrimaryKeys( TBool aCapture )
+{
+_AKNTRACE_FUNC_ENTER;
+if ( aCapture )
+{
+if ( iScreenSaverActive && !iCaptured )
+{
+if ( iKeylockEnabled && !iAutolockEnabled )
+{
+iCaptured = ETrue;
+// If no unlocking policy has been defined,
+// the default primary key is the left soft key.
+if ( !iUnlockPolicyApi )
+{
+// Capture LSK (starts unlock prosess, capturing
+// bypasses screensaver)
+iLeftSoftKey = iWindowGroup.CaptureKey( EKeyDevice0, 0, 0 );
+}
+else
+{
+iPrimaryKeyCaptures.Reset();
+TUint32 index( 0 );
+TUint32 primaryKey( 0 );
+TUint32 secondaryKey( 0 );
+while ( iUnlockPolicyApi->GetKeyCombination( index,
+primaryKey,
+secondaryKey ) == KErrNone )
+{
+if (KErrNone != iPrimaryKeyCaptures.Append(iWindowGroup.CaptureKeyUpAndDowns(primaryKey, 0, 0)))
+{
+return;
+}
+index++;
+}
+}
+}
+else
+{
+if ( iKeylockEnabled && iAutolockEnabled )
+{
+iCaptured = ETrue;
+// If no devicelock query policy has been defined,
+// the default primary key is the left soft key.
+if ( !iDevicelockPolicyApi )
+{
+// Capture LSK (starts unlock prosess,
+// capturing bypasses screensaver).
+iLeftSoftKey = iWindowGroup.CaptureKey( EKeyDevice0, 0, 0 );
+}
+else
+{
+iPrimaryKeyCaptures.Reset();
+TUint32 index( 0 );
+TUint32 primaryKey( 0 );
+TUint32 secondaryKey( 0 );
+while ( iDevicelockPolicyApi->GetKeyCombination( index, primaryKey, secondaryKey ) == KErrNone )
+{
+if (KErrNone != iPrimaryKeyCaptures.Append(iWindowGroup.CaptureKeyUpAndDowns(primaryKey, 0, 0)))
+{
+return;
+}
+index++;
+}
+}
+}
+}
+}
+}
+else
+{
+if (iCaptured)
+{
+if (iLeftSoftKey > 0)
+{
+iWindowGroup.CancelCaptureKey(iLeftSoftKey);
+}
+iLeftSoftKey = 0;
+if (iPrimaryKeyCaptures.Count() > 0)
+{
+for (TInt x = 0; x < iPrimaryKeyCaptures.Count(); x++)
+{
+iWindowGroup.CancelCaptureKeyUpAndDowns(iPrimaryKeyCaptures[x]);
+}
+iPrimaryKeyCaptures.Reset();
+}
+iCaptured = EFalse;
+}
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// From base class CActive.
+// Cancels event listening.
+// ---------------------------------------------------------------------------
+//
+void CAknKeylockScreenSaverObserver::DoCancel()
+{
+_AKNTRACE_FUNC_ENTER;
+iScreenSaverActiveProperty.Cancel();
+_AKNTRACE_FUNC_EXIT;
+}
 // ===========================================================================
 // class CAknLockedNote.
 // ===========================================================================
 // Handles a dialog button press for the button with ID aCommand.
 // ---------------------------------------------------------------------------
 //
 TBool CAknLockedNote::OkToExitL( TInt aCommand )
 {
+_AKNTRACE_FUNC_ENTER;
 iLocked = EFalse;
 if ( iCommandObserver )
 {
 iCommandObserver->ProcessCommandL( aCommand );
 }
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Cancels the note.
 // ---------------------------------------------------------------------------
 //
 void CAknLockedNote::CancelNote()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iTimer )
 {
 iTimer->Cancel();
 }
 ExitSleepingDialog();
 iLocked = EFalse;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CEikDialog.
 // Handles focus change event.
 // ---------------------------------------------------------------------------
 //
 void CAknLockedNote::FocusChanged( TDrawNow /*aDrawNow*/ )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !IsFocused() && iCommandObserver )
 {
 TRAP_IGNORE( iCommandObserver->ProcessCommandL( KNoteCmdFocusLost ) )
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CEikDialog.
 // Displays the note.
 // ---------------------------------------------------------------------------
 //
 TInt CAknSleepingNote::ShowNote( const TInt aTimeout, const TTone aTone )
 {
+_AKNTRACE_FUNC_ENTER;
 TRAP_IGNORE(AknGlobalPopupPriorityController::SetPopupPriorityL( *this, KGlobalWindowPriority_KeyLock ));
 iTimeoutInMicroseconds = aTimeout;
 iTone = aTone;
+_AKNTRACE_FUNC_EXIT;
 return RouseSleepingDialog();
 }
 // ---------------------------------------------------------------------------
 // Handles a dialog button press for the button with ID aCommand.
 // ---------------------------------------------------------------------------
 //
 TBool CAknSleepingNote::OkToExitL( TInt aCommand )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iCommandObserver )
 {
 iCommandObserver->ProcessCommandL( aCommand );
 }
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Updates the note animation on skin change event.
 // ---------------------------------------------------------------------------
 //
 void CAknSleepingNote::HandleResourceChange( TInt aType )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aType == KAknsMessageSkinChange )
 {
 TInt animationRes( 0 );
 switch ( iResourceId )
 {
 }
 }
 }
 CAknNoteDialog::HandleResourceChange( aType );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CEikDialog.
 // Sets the emergency number to be displayed.
 // ---------------------------------------------------------------------------
 //
 void CAknEcsNote::SetEmergencyNumber( const TDesC& aMatchedNumber )
 {
+_AKNTRACE_FUNC_ENTER;
 TRect mainPane;
 AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EPopupParent,
 mainPane );
 TAknLayoutRect popupNoteWindow;
 number.Append( ' ' );
 }
 number.Append( aMatchedNumber );
 TRAP_IGNORE( SetTextL( number ) );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Makes the note go to sleep.
 // ---------------------------------------------------------------------------
 //
 void CAknEcsNote::SleepNote()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iNoteOnScreen )
 {
 // Causes flicker to other notes if called when note is not on screen.
 ExitSleepingDialog();
 }
 iNoteOnScreen = EFalse;
+_AKNTRACE_FUNC_EXIT;
 }
 // ===========================================================================
 // class CAknKeyLockControl
 // ---------------------------------------------------------------------------
 //
 CAknKeyLockControl::CAknKeyLockControl( CAknKeyLockNotifierSubject* aNotif ) :
 iNotif( aNotif )
 {
+_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_ADD( this, "CAknKeyLockControl" );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Destructor
 // ---------------------------------------------------------------------------
 //
 CAknKeyLockControl::~CAknKeyLockControl()
 {
+_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
 // We implicitely trust that Eikon env exists
 // (though in practice it does not make the
 // difference as this destructor is really never called...)
 RWindowGroup& groupWin = iEikonEnv->RootWin();
 delete iEcsDetector;
 delete iKeyLockCba;
 delete iOfferLockNote;
 delete iEcsNote; // Ecs change
 delete iKeylockApi;
+delete iKeylockScreenSaverObserver;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Second phase construction.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::ConstructL()
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::ConstructL ")); )
+_AKNTRACE_FUNC_ENTER;
 FeatureManager::InitializeLibL();
 iFeatureKeypadNoSlider =
 FeatureManager::FeatureSupported( KFeatureIdKeypadNoSlider );
 iFeatureNoPowerkey =
 iOfferLockNote->ConstructSleepingNoteL( R_KEYLOCK_OFFER_LOCK_NOTE );
 iOfferLockNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition( 0, 2 );
 TBool touchEnabled( AknLayoutUtils::PenEnabled() );
-	TBool hasSlider(iHardwareSupport != EKeyguardDefaultHardware);
+TBool hasSlider = HasSliderKey();
 iKeyLockCba = CEikButtonGroupContainer::NewL(
 CEikButtonGroupContainer::ECba,
 CEikButtonGroupContainer::EHorizontal,
 this,
 (touchEnabled&&hasSlider) ? R_AVKON_SOFTKEYS_EMPTY :
 // Keylock API not initialized.
 delete iKeylockApi;
 iKeylockApi = NULL;
 }
+iKeylockScreenSaverObserver =
+CAknKeylockScreenSaverObserver::NewL( groupWin );
 // Define P&S key that is used to publish the keyguard status.
 RProperty::Define( KPSUidAvkonDomain,
 KAknKeyguardStatus,
 RProperty::EInt,
 TSecurityPolicy( TSecurityPolicy::EAlwaysPass ),
 KWritePolicy );
 iStatusProperty.Attach( KPSUidAvkonDomain, KAknKeyguardStatus );
 iStatusProperty.Set( EKeyguardNotActive );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Enable key lock.
 // ---------------------------------------------------------------------------
 //
-void CAknKeyLockControl::EnableKeylock( TBool aShowNote )
+void CAknKeyLockControl::EnableKeylock( TBool aShowNote, TBool aNotifySysApp )
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::EnableKeylock %d"), aShowNote); )
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE("aShowNote:%d",aShowNote);
+_AKNTRACE("aNotifySysApp:%d",aNotifySysApp);
 // Policy can be used to disable support for keyguard.
 if ( !iAutolockEnabled && !CKeyLockPolicyApi::KeyguardAllowed() )
 {
 // Keylock Disabled
 return;
 }
+// Keylock Enabled
+iKeylockScreenSaverObserver->SetLockStatus( ETrue, iAutolockEnabled );
 if ( iOfferLockEnabled )
 {
 iOfferLockNote->CancelNote();
 }
 // Update keyguard status to P&S system.
 iStatusProperty.Set( iAutolockEnabled ? EKeyguardAutolockEmulation :
 EKeyguardLocked );
 iKeyLockEnabled = ETrue;
-if ( !iAutolockEnabled )
+if ( !iAutolockEnabled && aNotifySysApp )
 {
 SendMessageToSysAp( EEikKeyLockEnabled );
 }
+TBool hasSliderKey = HasSliderKey();
-if ( !AknLayoutUtils::PenEnabled() || iHardwareSupport == EKeyguardDefaultHardware)
+if ( !AknLayoutUtils::PenEnabled() || !hasSliderKey)
 {
 iKeyLockCba->MakeVisible( ETrue );
 }
 else
 {
 if ( aShowNote )
 {
 DisplayLockedNote();
 }
-if ( !AknLayoutUtils::PenEnabled() || iHardwareSupport == EKeyguardDefaultHardware)
+if ( !AknLayoutUtils::PenEnabled() || !hasSliderKey)
 {
 ShowKeylockCba();
 }
 else
 {
 {
 Window().SetBackgroundColor( ~0 );
 }
 }
-		// in case Telephone-app is topmost, then the user is confused because he sees but can't use it.
+// in case Telephone-app is topmost, then the user is confused because he sees but can't use it.
-		// therefore it's required to hide it, by sending to background. ETMA-7M8A2Y 20090105
+// therefore it's required to hide it, by sending to background. ETMA-7M8A2Y 20090105
-		if ( AknLayoutUtils::PenEnabled() )
+if ( AknLayoutUtils::PenEnabled() )
-	{
+{
-	   			TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());
+TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());
-	   			#define KPhoneAppUid TUid::Uid(0x100058B3)
+#define KPhoneAppUid TUid::Uid(0x100058B3)
-			TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);
+TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);
-			if (apaTask.Exists())
+if (apaTask.Exists())
-	{
+{
-				 		#if defined(_DEBUG)
+#if defined(_DEBUG)
-				 			RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::EnableKeylock() Bring phone to background"));
+RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::EnableKeylock() Bring phone to background"));
-				 		#endif
+#endif
-		// Bring phone to background
+// Bring phone to background
-		apaTask.SendToBackground();
+apaTask.SendToBackground();
-	}
+}
-				}
+}
 // Start capturing system keys.
 CaptureSystemKeys();
 // Capture all pointer events.
 // Method HandleResourceChangeL with parameter KAknInternalFSWClose cannot
 // leave, but we trap it in just in case.
 TRAP_IGNORE( static_cast<CAknCapAppServerAppUi*>( iEikonEnv->EikAppUi() )->HandleResourceChangeL(
 KAknInternalFSWClose ); );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Disable key lock.
 // ---------------------------------------------------------------------------
 //
-void CAknKeyLockControl::DisableKeylock()
+void CAknKeyLockControl::DisableKeylock(TBool aNotifySysApp)
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::DisableKeylock")); )
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE("aShowNote:%d",aNotifySysApp);
+// Keep locking status in sync.
+iKeylockScreenSaverObserver->SetLockStatus( EFalse, iAutolockEnabled );
 if ( iSoundsMuted )
 {
 CAknAppUiBase* appUi= iAvkonAppUiBase;
 appUi->KeySounds()->ReleaseContext();
 appUi->KeySounds()->PopContext();
 // Update keyguard status to P&S system.
 iStatusProperty.Set( EKeyguardNotActive );
 iKeyLockEnabled = EFalse;
-if ( !iAutolockEnabled )	// only when Autolock was user-activated
+if ( !iAutolockEnabled )    // only when Autolock was user-activated
 {
-		    // in case Telephone-app was topmost and sent to background, then the user is confused because he expects to see it again.
+// in case Telephone-app was topmost and sent to background, then the user is confused because he expects to see it again.
-				// therefore it's required to show it, by sending to foreground.
+// therefore it's required to show it, by sending to foreground.
-				if ( AknLayoutUtils::PenEnabled() )
+if ( AknLayoutUtils::PenEnabled() )
-		     	{
+{
-	    TInt callState;
+TInt callState;
-	    RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
-	    #if defined(_DEBUG)
+#if defined(_DEBUG)
-						RDebug::Printf( "%s %s (%u) callState=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, callState );
+RDebug::Printf( "%s %s (%u) callState=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, callState );
-						RDebug::Printf( "%s %s (%u) EPSCTsyCallStateNone=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, EPSCTsyCallStateNone );
+RDebug::Printf( "%s %s (%u) EPSCTsyCallStateNone=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, EPSCTsyCallStateNone );
-					#endif
+#endif
 if (callState != EPSCTsyCallStateNone )
 {
+TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());
-				   			TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());
+#define KPhoneAppUid TUid::Uid(0x100058B3)
-				   			#define KPhoneAppUid TUid::Uid(0x100058B3)
+TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);
+if (apaTask.Exists())
-				   			TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);
+{
-				   			if (apaTask.Exists())
+RDebug::Printf( "%s %s (%u) foreground=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 1 );
-				       	{
+#if defined(_DEBUG)
-									RDebug::Printf( "%s %s (%u) foreground=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 1 );
+RDebug::Print(_L("(AUTOLOCK)CAknKeyLockControl::EnableKeylock() Send phone to foreground"));
-							 		#if defined(_DEBUG)
+#endif
-							 			RDebug::Print(_L("(AUTOLOCK)CAknKeyLockControl::EnableKeylock() Send phone to foreground"));
+// Bring phone to foreground
-							 		#endif
+apaTask.BringToForeground();
-				       		// Bring phone to foreground
+}
-				       		apaTask.BringToForeground();
+}
-				       	}
+}   // PenEnabled()
-		       		}
+}
-					}	// PenEnabled()
+	if (aNotifySysApp)
-SendMessageToSysAp( EEikKeyLockDisabled );
+		{
-}
+		SendMessageToSysAp( EEikKeyLockDisabled );
-if ( iNotif )
+		}
+	if ( iNotif )
 {
 iNotif->NotifyStatusChange( EKeyLockDisabled );
 }
 // Basically this cannot fail so we ignore return code.
 static_cast<CAknNotifierAppServerAppUi*>(
 iEikonEnv->EikAppUi() )->SuppressAppSwitching( EFalse );
 iAutolockEnabled = EFalse;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Sends a message to the SysAp window group.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::SendMessageToSysAp( TInt aMessage )
 {
+_AKNTRACE_FUNC_ENTER;
 RWsSession& ws = iEikonEnv->WsSession();
 TInt wgId = 0;
 CApaWindowGroupName::FindByAppUid( KSysApUid, ws, wgId );
 if ( wgId )
 {
 TWsEvent event;
 event.SetType( aMessage );
 event.SetTimeNow();
 ws.SendEventToWindowGroup( wgId, event );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Displays the "offer keylock" note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::OfferKeylock()
 {
+_AKNTRACE_FUNC_ENTER;
 iOfferLockNote->ShowNote( (CAknNoteDialog::TTimeout)KAknOfferKeyLockTimeout,
 CAknNoteDialog::ENoTone );
 iOfferLockEnabled = ETrue;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Displays the "locked" note.
 //
 void CAknKeyLockControl::DisplayLockedNote()
 {
 if ( !iAutolockEnabled )
 {
-iKeypadLockedNote->ShowNote( KKeyLockCustomShortTimeout,
-CAknNoteDialog::ENoTone );
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::DisplayKeyActiveNote()
 {
 if ( !iAutolockEnabled )
 {
-iKeypadUnlockedNote->ShowNote( KKeyLockCustomShortTimeout,
-CAknNoteDialog::ENoTone );
 }
 }
 // ---------------------------------------------------------------------------
 // Unlocks the keypad and displays the "keys active" note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::DoUnlock()
 {
+_AKNTRACE_FUNC_ENTER;
 DisableKeylock();
 DisplayKeyActiveNote();
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CCoeControl.
 // Handles resource change events.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::HandleResourceChange( TInt aType )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE("aType:%d",aType);
 if ( aType == KEikDynamicLayoutVariantSwitch )
 {
 TRect screenRect;
 AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );
 if ( !AknLayoutUtils::PenEnabled() )
 {
 Window().SetBackgroundColor( ~0 );
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class MEikCommandObserver.
 // Process commands.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::ProcessCommandL( TInt aCommandId )
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::ProcessCommandL %d"), aCommandId); )
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE("aCommandId:%d",aCommandId);
 switch ( aCommandId )
 {
 case EAknSoftkeyUnlock:
 {
 default:
 {
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CCoeControl.
 // Handles LSK keypress.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::LeftSoftKeyPressed()
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::LeftSoftKeyPressed")); )
+_AKNTRACE_FUNC_ENTER;
 // Check that the confirmation note exists, as it's not created on
 // startup if touch layout is in use. In emulator this might cause
 // a problem, as layout can be changed to a non-touch one, and
 // the confirmation notes do not exist.
 if ( iConfirmationNote )
 CAknNoteDialog::EConfirmationTone );
 }
 SendMessageToSysAp( EEikKeyLockLightsOnRequest );
 iUnlockConfirmation = ETrue;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class CCoeControl.
 // ---------------------------------------------------------------------------
 //
 TKeyResponse CAknKeyLockControl::OfferKeyEventL( const TKeyEvent& aKeyEvent,
 TEventCode aType )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( AknLayoutUtils::PenEnabled() )
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: PenEnabled"));)
+_AKNTRACE("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: PenEnabled");
 if ( iAutolockEnabled )
 { // The case when touch device is locked and so must be unlocked by hold switch.
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: Autolock Enabled"));)
+_AKNTRACE("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: Autolock Enabled");
 if ( aType == EEventKey && aKeyEvent.iCode == EKeyDeviceF )
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: SysAp message"));)
+_AKNTRACE("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: SysAp message");
 SendMessageToSysAp( EEikKeyLockLightsOnRequest );
 if ( iAutolockEnabled && !iKeylockApi )
 {
 TApaTaskList tasklist( iCoeEnv->WsSession() );
 TApaTask autolocktask = tasklist.FindApp( KAutolockUid );
 TKeyEvent keyEvent;
 keyEvent.iCode = EKeyBell;
 autolocktask.SendKey( keyEvent );
 }
 }
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::OfferKeyEventL: return EKeyWasConsumed"));)
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 }
 }
 aKeyEvent.iScanCode == EStdKeyRightShift ) )
 {
 ShowLockedNote();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 // ---------------------------------------------------------------------------
 // Shows the "locked" note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::ShowLockedNote()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iLockedNoteDisplayed )
 {
 DoShowLockedNote();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Shows the "locked" note.
 //
 void CAknKeyLockControl::DoShowLockedNote()
 {
 if ( !iAutolockEnabled )
 {
-iLockedNote->ShowNote( KKeyLockDisplayLockedTimeout,
-CAknNoteDialog::ENoTone );
-iLockedNoteDisplayed = ETrue;
 }
 }
 // ---------------------------------------------------------------------------
 // Brings the keylock notifier's CBA visible.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::ShowKeylockCba()
 {
+_AKNTRACE_FUNC_ENTER;
 RDrawableWindow* cbaWindow =
 iKeyLockCba->ButtonGroup()->AsControl()->DrawableWindow();
 cbaWindow->SetFaded( EFalse, RWindowTreeNode::EFadeWindowOnly );
 cbaWindow->SetOrdinalPosition( 0, 1 );
 cbaWindow->SetNonFading( ETrue );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Sets the necessary HW keys captured.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::CaptureSystemKeys()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iKeysCaptured )
 {
 RWindowGroup& groupWin = iCoeEnv->RootWin();
 // Capture app key (disable application switching).
 iHoldSwitch = 0;
 if ( AknLayoutUtils::PenEnabled() )
 {
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::CaptureSystemKeys PenEnabled"));)
+_AKNTRACE("(KeyGuard)CAknKeyLockControl::CaptureSystemKeys PenEnabled");
 if ( iAutolockEnabled )
 { //Capture Hold Switch
-TRACES( RDebug::Print(_L("(KeyGuard)CAknKeyLockControl::CaptureSystemKeys iAutolockEnabled"));)
+_AKNTRACE("(KeyGuard)CAknKeyLockControl::CaptureSystemKeys iAutolockEnabled");
 iHoldSwitch = groupWin.CaptureKey( EKeyDeviceF, 0, 0 );
 }
 }
 iKeysCaptured = ETrue;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Releases captured HW keys.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::UnCaptureSystemKeys()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iKeysCaptured )
 {
 RWindowGroup& groupWin = iCoeEnv->RootWin();
 groupWin.CancelCaptureKeyUpAndDowns( iAppKey );
 groupWin.CancelCaptureKeyUpAndDowns( iPowerKey );
 groupWin.CancelCaptureKey( iHoldSwitch );
 }
 iKeysCaptured = EFalse;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class MAknEcsObserver.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::HandleEcsEvent( CAknEcsDetector* aEcsDetector,
 CAknEcsDetector::TState aState )
 {
+_AKNTRACE_FUNC_ENTER;
 switch ( aState )
 {
 case CAknEcsDetector::ECompleteMatchThenSendKey:
 {
 // Do nothing since note will be removed on ECallAttempted event.
 break;
 }
 case CAknEcsDetector::ECompleteMatch:
+case CAknEcsDetector::EServiceNumMatch:
 {
 iEcsNote->SetEmergencyNumber( aEcsDetector->CurrentMatch() );
 iEcsNote->ShowNote( CAknNoteDialog::ENoTimeout,
 CAknNoteDialog::ENoTone );
 default:
 {
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Cancels the offer keylock note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::DoExitOfferKeylock()
 {
+_AKNTRACE_FUNC_ENTER;
 iOfferLockNote->CancelNote();
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Cancels the offer keylock note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::OfferTimerExpired()
 {
+_AKNTRACE_FUNC_ENTER;
 DoExitOfferKeylock();
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Sets the autolock state.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::AutolockEnabled( TBool aAutoLockOn )
 {
+_AKNTRACE_FUNC_ENTER;
 iAutolockEnabled = aAutoLockOn;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // For CDMA implementation.
 // For capturing pointer events when key lock is enabled.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::CapturePointerEvents()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( AknLayoutUtils::PenEnabled() )
 {
 Window().SetPointerCapture( RWindowBase::TCaptureDragDrop );
 Window().ClaimPointerGrab( ETrue );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // For releasing pointer events when key lock is disabled.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockControl::UnCapturePointerEvents()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( AknLayoutUtils::PenEnabled() )
 {
 Window().SetPointerCapture( RWindowBase::TCaptureDisabled );
 Window().ClaimPointerGrab( EFalse );
 }
+_AKNTRACE_FUNC_EXIT;
+}
+TBool CAknKeyLockControl::HasSliderKey()
+{
+_AKNTRACE_FUNC_ENTER;
+TBool hasSlider(iHardwareSupport != EKeyguardDefaultHardware);
+if( FeatureManager::FeatureSupported( KFeatureIdFfPowerKeyAsKeyguard ) )
+{
+hasSlider = ETrue;  // the only purpose is to display empty sotkeys
+}
+_AKNTRACE( "hasSlider:%d",hasSlider);
+_AKNTRACE_FUNC_EXIT;
+return hasSlider;
 }
 // ===========================================================================
 // class CAknKeyLockNotifierSubject
 // Starts the keylock notifier synchronously.
 // ---------------------------------------------------------------------------
 //
 TPtrC8 CAknKeyLockNotifierSubject::StartL( const TDesC8& aBuffer )
 {
+_AKNTRACE_FUNC_ENTER;
 SAknNotifierPackage<SAknKeyLockNotifierParams>* params =
 ( SAknNotifierPackage<SAknKeyLockNotifierParams>*)aBuffer.Ptr();
 if ( aBuffer.Length() < 0 ||
 (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage<SAknKeyLockNotifierParams>) ||
 params->iSignature != KAKNNOTIFIERSIGNATURE )
 {
 User::Leave( KErrArgument );
 }
+_AKNTRACE( "params->iParamData.iReason:%d",params->iParamData.iReason);
 switch ( params->iParamData.iReason )
 {
 case ELockEnabled:
 case ELockDisabled:
 case EAllowNotifications:
 {
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return iRetPckg;
 }
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::StartL( const TDesC8& aBuffer,
 TInt /*aReplySlot*/,
 const RMessagePtr2& aMessage )
 {
+_AKNTRACE_FUNC_ENTER;
 SAknNotifierPackage<SAknKeyLockNotifierParams>* params =
 ( SAknNotifierPackage<SAknKeyLockNotifierParams>*)aBuffer.Ptr();
 if ( aBuffer.Length() < 0 ||
 (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage<SAknKeyLockNotifierParams>) ||
 params->iSignature != KAKNNOTIFIERSIGNATURE )
 {
 User::Leave( KErrArgument );
 }
+_AKNTRACE( "params->iParamData.iReason:%d",params->iParamData.iReason);
 switch ( params->iParamData.iReason )
 {
 case ELockEnabled:
 {
 if ( !iKeyLockControl->iAutolockEnabled )
 {
 break;
 }
 };
+_AKNTRACE_FUNC_EXIT;
 aMessage.Complete( KErrNone );
 }
 // ---------------------------------------------------------------------------
 // Disables the keylock.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::UnlockKeys()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( IsKeyLockEnabled() )
 {
 iKeyLockControl->DisableKeylock();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class MAknKeyLockController.
 // Enables the keylock.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::LockKeys( TBool aAutoLockOn )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE( "aAutoLockOn:%d",aAutoLockOn);
 // We'll have to disable keylock if we are changing autolock status.
 if ( IsKeyLockEnabled() && aAutoLockOn != iKeyLockControl->iAutolockEnabled )
 {
-iKeyLockControl->DisableKeylock();
+iKeyLockControl->DisableKeylock(EFalse);
 }
 if ( !IsKeyLockEnabled() )
 {
 iKeyLockControl->AutolockEnabled( aAutoLockOn );
-iKeyLockControl->EnableKeylock();
+iKeyLockControl->EnableKeylock(ETrue, EFalse);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class MAknKeyLockController.
 // Adds a keylock status change observer.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::AddObserverL( MAknKeyLockObserver* aObserver )
 {
+_AKNTRACE_FUNC_ENTER;
 #if defined(_DEBUG)
 TInt count = iObserverList->Count();
 for ( TInt index = 0; index < count; index++ )
 {
 if ( ((*iObserverList)[index]) == aObserver )
 #endif
 iObserverList->AppendL( aObserver );
 // Make sure that the observer isn't obscuring the keylock CBA
 ShowKeylockCba();
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // From base class MAknKeyLockController.
 // Removes a keylock status change observer.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::RemoveObserver( MAknKeyLockObserver* aObserver )
 {
+_AKNTRACE_FUNC_ENTER;
 TInt count = iObserverList->Count();
 for ( TInt index = 0; index < count; index++ )
 {
 if ( ((*iObserverList)[index]) == aObserver )
 {
 }
 }
 #if defined(_DEBUG)
 Panic( EAknPanicKeyLockObserverNotFound );
 #endif
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Notifies the observers of a keylock status change.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::NotifyStatusChange( TKeyLockStatus aStatus )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE( "aStatus:%d",aStatus);
 TInt count = iObserverList->Count();
 for ( TInt index = count - 1; index >= 0; index-- )
 {
 ((*iObserverList)[index])->KeyLockStatusChange( aStatus );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Brings the keylock notifier's CBA visible.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::ShowKeylockCba()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( IsKeyLockEnabled() )
 {
 iKeyLockControl->ShowKeylockCba();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Enables the keylock.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::DoEnableKeyLock()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !IsKeyLockEnabled() )
 {
 iKeyLockControl->EnableKeylock();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Disables the keylock if active.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::DoDisableKeyLock()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( IsKeyLockEnabled() )
 {
 iKeyLockControl->DisableKeylock();
 // Attempt to display KeyActive note.
 iKeyLockControl->DisplayKeyActiveNote();
 else if ( iKeyLockControl->iOfferLockEnabled )
 {
 // Remove the offer key lock CBA.
 iKeyLockControl->OfferTimerExpired();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Displays the offer keylock note.
 // ---------------------------------------------------------------------------
 //
 void CAknKeyLockNotifierSubject::DoOfferKeyLock()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !IsKeyLockEnabled() )
 {
 NotifyStatusChange( EKeyLockOffered );
 iKeyLockControl->OfferKeylock();
 }
-}
+_AKNTRACE_FUNC_EXIT;
+}

branch	RCL_3
changeset 20	d48ab3b357f1
parent 19	aecbbf00d063