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

equal deleted inserted replaced

-:a8834a2e9a96
+:c52421ed5f07
 #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
 // 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
 // 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 ) );
 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();
 }
 {
 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 )
 {
 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 )
 TUint32 secondaryKey( 0 );
 while ( iUnlockPolicyApi->GetKeyCombination( index,
 primaryKey,
 secondaryKey ) == KErrNone )
 {
-iPrimaryKeyCaptures.Append(
+if (KErrNone != iPrimaryKeyCaptures.Append(iWindowGroup.CaptureKeyUpAndDowns(primaryKey, 0, 0)))
-iWindowGroup.CaptureKeyUpAndDowns( primaryKey, 0, 0 ) );
+{
+return;
+}
 index++;
 }
 }
 }
 else
 TUint32 index( 0 );
 TUint32 primaryKey( 0 );
 TUint32 secondaryKey( 0 );
 while ( iDevicelockPolicyApi->GetKeyCombination( index, primaryKey, secondaryKey ) == KErrNone )
 {
-iPrimaryKeyCaptures.Append(
+if (KErrNone != iPrimaryKeyCaptures.Append(iWindowGroup.CaptureKeyUpAndDowns(primaryKey, 0, 0)))
-iWindowGroup.CaptureKeyUpAndDowns( primaryKey, 0, 0 ) );
+{
+return;
+}
 index++;
 }
 }
 }
 }
 }
 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 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 =
 TSecurityPolicy( TSecurityPolicy::EAlwaysPass ),
 KWritePolicy );
 iStatusProperty.Attach( KPSUidAvkonDomain, KAknKeyguardStatus );
 iStatusProperty.Set( EKeyguardNotActive );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Enable key lock.
 // ---------------------------------------------------------------------------
 //
 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;
 // 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(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 )
 {
 // 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.
 // 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.
 // 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.
 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;
 }
 // ===========================================================================
 // 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(EFalse);
 }
 if ( !IsKeyLockEnabled() )
 {
 iKeyLockControl->AutolockEnabled( aAutoLockOn );
 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 38	c52421ed5f07
parent 29	a8834a2e9a96
child 55	aecbbf00d063