diff -r 000000000000 -r 2f259fa3e83a uifw/AknGlobalUI/cdma/notpisrc/aknkeylocknotifierCdma.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AknGlobalUI/cdma/notpisrc/aknkeylocknotifierCdma.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,1432 @@
+// PLEASE NOTE: THIS FILE HAS NOT YET BEEN MIGRATED TO NEW NOTIFIER SYSTEM !!!
+
+/*
+* Copyright (c) 2002 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".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Avkon KeyLock Notifier
+*
+*/
+
+
+#include "AknKeyLockNotifier.h"
+#include "AknNotifyPlugin.h"
+#include "AknNotifyPlugin.hrh"
+
+#include <aknnotpi.rsg>
+#include <eikenv.h>
+#include <eikappui.h>
+#include <aknkeys.h>
+#include <coedef.h>
+
+#include <uikon/eiksrvui.h>
+#include <eikon.hrh>
+#include <apgwgnam.h>
+#include <aknsoundsystem.h>
+#include <avkon.rsg>
+#include <akndlgshut.h>
+#include <eikkeysound.h>
+#include <bautils.h>
+#include <FeatMgr.h>
+
+#include <aknlayout.lag>
+#include <aknutils.h>
+#include <eikcba.h>
+#include <aknsconstants.h>
+#include <aknnotecontrol.h>
+#include <AknLayoutScalable_Avkon.cdl.h>
+
+#ifdef __COVER_DISPLAY
+#include "AknPublishToCoverUI.h"
+#endif // __COVER_DISPLAY
+
+#include <AknNotifySignature.h>
+
+#include <AiwServiceHandler.h>
+#include <AiwCommon.hrh>
+
+#include <akntashook.h>
+#define KSysApUid TUid::Uid(0x100058F3)
+
+const TInt KAknObserverListGranularity = 4;
+const TInt KAknOfferKeyLockTimeout = 6000000; // 6sec
+
+const TInt KNoteCmdFocusLost = 3100;
+
+const TUint KAknAsterisk = '*';
+const TUint KAknHash = '#';
+const TInt KKeyLockControlAnyKey = 3300;    // phone query
+
+_LIT(KRESOURCEFILE,"z:\\private\\10003a4a\\aknnotpi.rsc");
+
+// CAknLockedNote
+
+CAknLockedNote::CAknLockedNote(TInt& aLocked, MEikCommandObserver* aCommandObserver)
+:CAknSleepingNote(aCommandObserver), iLocked(aLocked)
+    {
+    AKNTASHOOK_ADD( this, "CAknLockedNote" );
+    }
+
+TBool CAknLockedNote::OkToExitL(TInt aCommand)
+    {
+    iLocked = EFalse;
+
+    if (iCommandObserver)
+        {
+        iCommandObserver->ProcessCommandL(aCommand);
+        }
+
+    return ETrue;
+    }
+
+CAknLockedNote::~CAknLockedNote()
+    {
+    AKNTASHOOK_REMOVE();
+    iLocked = EFalse;
+    }
+
+void CAknLockedNote::CancelNote()
+    {
+    if ( iTimer )
+        iTimer->Cancel();
+    CAknNoteControl* ctrl = 0;
+    ctrl = NoteControl();
+    if ( ctrl )
+        { // if there is no animation, just returns KErrGeneral
+        ctrl->CancelAnimation();
+        }
+    ExitSleepingDialog();
+    iLocked = EFalse;
+    }
+
+void CAknLockedNote::FocusChanged(TDrawNow /*aDrawNow*/)
+    {
+    if (!IsFocused() &&  iCommandObserver)
+        {
+        TRAP_IGNORE(iCommandObserver->ProcessCommandL(KNoteCmdFocusLost))
+        }
+    }
+
+
+void CAknLockedNote::CEikDialog_Reserved_1()
+    {
+    }
+
+void CAknLockedNote::CEikDialog_Reserved_2()
+    {
+    }
+
+void CAknLockedNote::CAknNoteDialog_Reserved()
+    {
+    }
+
+void CAknLockedNote::CAknSleepingNote_Reserved()
+    {
+    }
+
+
+CAknSleepingNote::CAknSleepingNote(MEikCommandObserver* aCommandObserver)
+:iCommandObserver(aCommandObserver)
+    {
+    AKNTASHOOK_ADD( this, "CAknSleepingNote" );
+    }
+
+
+void CAknSleepingNote::ConstructSleepingNoteL(TInt aResourceId)
+    {
+    iResourceId = aResourceId;
+    CAknNoteDialog::ConstructSleepingDialogL(aResourceId);
+    // Construct now rather than in PreLayoutDynInit
+    delete iTimer;
+    iTimer = 0;
+
+    iTimer = CPeriodic::NewL(0);
+    }
+
+TInt CAknSleepingNote::ShowNote(const TTimeout aTimeout,const TTone aTone)
+    {
+    ReportUserActivity();
+    iTimeoutInMicroseconds = aTimeout;
+    iTone = aTone;
+    return RouseSleepingDialog();
+    }
+
+TBool CAknSleepingNote::OkToExitL(TInt aCommand)
+    {
+    if (iCommandObserver)
+        {
+        iCommandObserver->ProcessCommandL(aCommand);
+        }
+    return ETrue;
+    }
+
+void CAknSleepingNote::HandleResourceChange(TInt aType)
+    {
+    if( aType == KAknsMessageSkinChange )
+        {
+        TInt animationRes(0);
+        switch (iResourceId)
+            {
+        case R_KEYLOCK_NOTE_KEYLOCKED:
+            animationRes = R_QGN_NOTE_INFO_ANIM;
+            break;
+        case R_KEYLOCK_NOTE_UNLOCK_CONFIRM:
+            animationRes = R_QGN_NOTE_QUERY_ANIM;
+            break;
+        case R_KEYLOCK_NOTE_UNLOCK_ASTERISK:
+            animationRes = R_QGN_NOTE_INFO_ANIM;
+            break;
+        case R_KEYLOCK_NOTE_LOCK_ON:
+            animationRes = R_QGN_NOTE_KEYGUARD_LOCKED_ANIM;
+            break;
+        case R_KEYLOCK_NOTE_LOCK_OFF:
+            animationRes = R_QGN_NOTE_KEYGUARD_OPEN_ANIM;
+            break;
+        case R_KEYLOCK_OFFER_LOCK_NOTE:
+            animationRes = R_QGN_NOTE_QUERY_ANIM;
+            break;
+        default:
+            break;
+        } // end of switch
+
+        if (animationRes)
+            {
+            CAknNoteControl* ctrl = 0;
+            ctrl = NoteControl();
+            if ( ctrl )
+                {
+                TRAP_IGNORE( ctrl->SetAnimationL( animationRes ));
+                }
+            }
+
+        }
+
+    CAknNoteDialog::HandleResourceChange(aType);
+    }
+
+
+void CAknSleepingNote::CEikDialog_Reserved_1()
+    {
+    }
+
+void CAknSleepingNote::CEikDialog_Reserved_2()
+    {
+    }
+
+void CAknSleepingNote::CAknNoteDialog_Reserved()
+    {
+    }
+
+void CAknSleepingNote::CAknSleepingNote_Reserved()
+    {
+    }
+
+
+/**
+* Private class to implement the emergency number display during keylock
+*
+*/
+class CAknEcsNote: public CAknSleepingNote
+    {
+public:
+    /**
+    * Constructor
+    */
+    CAknEcsNote( MEikCommandObserver* aCommandObserver );
+    /**
+    * API to set the emergency number to be displayed
+    *
+    * aMatchedNumber    text to display (e.g. "112" )
+    */
+    void SetEmergencyNumber( const TDesC& aMatchedNumber );
+    /**
+    * Dismisses the sleeping note.
+    */
+    void SleepNote();
+
+    TBool iNoteOnScreen;
+    };
+
+CAknEcsNote::CAknEcsNote( MEikCommandObserver* aCommandObserver ) : CAknSleepingNote( aCommandObserver )
+    {}
+
+void CAknEcsNote::SetEmergencyNumber( const TDesC& aMatchedNumber )
+    {
+    TRect screen(iAvkonAppUi->ApplicationRect());
+    TAknLayoutRect mainPane;
+    mainPane.LayoutRect(screen, AKN_LAYOUT_WINDOW_main_pane(screen, 0, 1, 1));
+    TAknLayoutRect popupNoteWindow;
+    AknLayoutUtils::TAknCbaLocation cbaLocation( AknLayoutUtils::CbaLocation() );
+	TInt variety( 0 );
+    if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )
+		{
+		variety = 5;
+		}
+	else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )
+		{
+		variety = 8;
+		}
+	else
+		{
+		variety = 2;
+		}
+
+    popupNoteWindow.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::popup_note_window( variety ));
+    TAknLayoutText textRect;
+    textRect.LayoutText(popupNoteWindow.Rect(), AKN_LAYOUT_TEXT_Note_pop_up_window_texts_Line_1(4));
+
+    // Size of a temporary buffer that contains new lines, spaces and 
+    // emergency number for a note.
+    TBuf16<KAknEcsMaxMatchingLength+80> number;
+    number.Append('\n');
+    number.Append('\n');
+
+    TInt spaceCharWidthInPixels = textRect.Font()->CharWidthInPixels(' ');
+    if (spaceCharWidthInPixels < 1)
+        {
+        // Avoid divide by zero situation even the space char would have zero length.
+        spaceCharWidthInPixels = 1;
+        }
+    
+    TInt length = (textRect.TextRect().Width() - textRect.Font()->TextWidthInPixels(aMatchedNumber))
+                    / spaceCharWidthInPixels;
+
+    const TInt matchedNumberLength = aMatchedNumber.Length();
+    const TInt numberLength = number.Length();
+    const TInt numberMaxLength = number.MaxLength();
+    
+    if ( numberLength + length + matchedNumberLength > numberMaxLength)
+        {
+        // To make sure that buffer overflow does not happen.
+        length = numberMaxLength - numberLength - matchedNumberLength;
+        }
+    for (int i = 0; i < length ; i++)
+        {
+        number.Append(' ');
+        }
+
+    number.Append(aMatchedNumber);
+    TRAP_IGNORE(SetTextL(number));
+
+    }
+
+void CAknEcsNote::SleepNote()
+    {
+    if (iNoteOnScreen)
+        ExitSleepingDialog(); // Causes flicker to other notes if called when note is not on screen
+    iNoteOnScreen = EFalse;
+    }
+
+//CaknLockedPhoneQuery
+CAknLockedPhoneQuery* CAknLockedPhoneQuery::NewL( TDes& aDataText )
+    {
+    CAknLockedPhoneQuery* self =
+        new(ELeave) CAknLockedPhoneQuery( aDataText );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    AKNTASHOOK_ADDL( self, "CAknLockedPhoneQuery" );
+    return self;
+    }
+
+CAknLockedPhoneQuery::~CAknLockedPhoneQuery()
+    {
+    AKNTASHOOK_REMOVE();
+    if ( iInactivityTimer )
+        {
+        iInactivityTimer->Cancel();
+        delete iInactivityTimer;
+        }
+    }
+
+CAknLockedPhoneQuery::CAknLockedPhoneQuery(TDes& aDataText)
+    : CAknTextQueryDialog(aDataText)
+    {
+    }
+
+void CAknLockedPhoneQuery::ConstructL()
+    {
+    iInactivityTimer = CPeriodic::NewL(CActive::EPriorityUserInput);
+    TCallBack callback(InactivityExitL, this);
+    iInactivityTimer->Start(KEcsInterKeyTimeout,
+        KEcsInterKeyTimeout, callback);
+    }
+
+TKeyResponse CAknLockedPhoneQuery::OfferKeyEventL(const TKeyEvent& aKeyEvent,
+                                                  TEventCode aType)
+    {
+    ResetInactivityTimer();
+    if(aKeyEvent.iCode == EKeyPhoneSend || aKeyEvent.iCode == EKeyOK)
+        {
+        TryExitL(EAknSoftkeyCall);
+        return EKeyWasConsumed;
+        }
+    if(aKeyEvent.iCode == EKeyPhoneEnd)
+        {
+        TryExitL(EAknSoftkeyCancel);
+        return EKeyWasConsumed;
+        }
+    return CAknTextQueryDialog::OfferKeyEventL(aKeyEvent, aType);
+    }
+
+void CAknLockedPhoneQuery::ResetInactivityTimer()
+    {
+    iInactivityTimer->Cancel();
+    TCallBack callback(InactivityExitL, this);
+    iInactivityTimer->Start(KEcsInterKeyTimeout,
+        KEcsInterKeyTimeout, callback);
+    }
+
+TInt CAknLockedPhoneQuery::InactivityExitL(TAny *aThis)
+    {
+    static_cast<CAknLockedPhoneQuery*>(aThis)->DoInactivityExitL();
+    return 0;
+    }
+
+void CAknLockedPhoneQuery::DoInactivityExitL()
+    {
+    TryExitL(EEikBidCancel);
+    }
+
+//CAknKeyLockControl
+
+CAknKeyLockControl::CAknKeyLockControl()
+    {
+    AKNTASHOOK_ADD( this, "CAknKeyLockControl" );
+    }
+
+CAknKeyLockControl::CAknKeyLockControl(CAknKeyLockNotifierSubject* aNotif):iNotif(aNotif)
+    {
+    AKNTASHOOK_ADD( this, "CAknKeyLockControl" );
+    }
+
+CAknKeyLockControl::~CAknKeyLockControl()
+    {
+    AKNTASHOOK_REMOVE();
+    FeatureManager::UnInitializeLib();
+    iEikonEnv->EikAppUi()->RemoveFromStack(this);
+    delete iConfirmationNote;
+    //Show note "Now press *".
+    //Note is shown when user has pressed "Unlock" when keypad is in locked state
+    delete iConfirmationNoteAsterisk;
+    delete iLockedNote;
+    delete iKeypadUnlockedNote;
+    delete iKeypadLockedNote;
+    delete iEcsDetector;
+    delete iKeyLockCba;
+    delete iOfferLockNote;
+    delete iEcsNote; // Ecs change
+    }
+
+void CAknKeyLockControl::ConstructL()
+    {
+    FeatureManager::InitializeLibL();
+    iFeatureKeypadNoSlider =
+        FeatureManager::FeatureSupported( KFeatureIdKeypadNoSlider );
+
+    CreateWindowL();
+    Window().SetSize(TSize(0,0));
+
+    ActivateL();
+
+    iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityEnvironmentFilter+10,ECoeStackFlagRefusesFocus);
+
+    iKeyLockCba = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba, CEikButtonGroupContainer::EHorizontal, this, R_KEYLOCK_SOFTKEYS_UNLOCK_EMPTY);
+    iKeyLockCba->ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(ECoeWinPriorityNeverAtFront);
+//    const TSize screenSize=TSize(AKN_LAYOUT_WINDOW_screen.iW,AKN_LAYOUT_WINDOW_screen.iH);  // Ok so far. 'screen' layout used.
+    const TSize screenSize( iAvkonAppUi->ApplicationRect().Size() );
+    iKeyLockCba->MakeVisible(EFalse);
+    iKeyLockCba->SetBoundingRect(TRect(screenSize));
+
+    iEcsNote = new (ELeave) CAknEcsNote( this );
+    iEcsNote->ConstructSleepingNoteL(R_AVKON_EMERGENCY_CALL_NOTE);
+    iEcsNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    iOfferLockNote = new(ELeave)CAknLockedNote(iOfferLockEnabled, this);
+    iOfferLockNote->ConstructSleepingNoteL(R_KEYLOCK_OFFER_LOCK_NOTE);
+    iOfferLockNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    iKeypadLockedNote = new(ELeave)CAknSleepingNote();
+    iKeypadLockedNote->ConstructSleepingNoteL(R_KEYLOCK_NOTE_LOCK_ON);
+    iKeypadLockedNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    iKeypadUnlockedNote = new(ELeave)CAknSleepingNote();
+    iKeypadUnlockedNote->ConstructSleepingNoteL(R_KEYLOCK_NOTE_LOCK_OFF);
+    iKeypadUnlockedNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    iLockedNote = new (ELeave)CAknLockedNote(iLockedNoteDisplayed);
+    iLockedNote->ConstructSleepingNoteL(R_KEYLOCK_NOTE_KEYLOCKED);
+    iLockedNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    iConfirmationNote = new (ELeave) CAknLockedNote(iUnlockConfirmation);
+    iConfirmationNote->ConstructSleepingNoteL(R_KEYLOCK_NOTE_UNLOCK_CONFIRM);
+    iConfirmationNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+    if ( iFeatureKeypadNoSlider )
+        {
+        //Show note "Now press *".
+        //Note is shown when user has pressed "Unlock" when keypad is in locked state
+        iConfirmationNoteAsterisk = new (ELeave) CAknLockedNote(iUnlockConfirmation);
+        iConfirmationNoteAsterisk->ConstructSleepingNoteL(R_KEYLOCK_NOTE_UNLOCK_ASTERISK);
+        iConfirmationNoteAsterisk->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+        }
+    // Emergency call support
+    iEcsDetector = CAknEcsDetector::NewL();
+    iEcsDetector->SetObserver( this );
+
+    iPhoneQueryOnScreen = EFalse;
+    iPhoneNumber.Zero();
+    }
+
+
+void CAknKeyLockControl::EnableKeylock(TBool aShowNote)
+    {
+    if (iOfferLockEnabled)
+        {
+        iOfferLockNote->CancelNote();
+        }
+    iKeyLockEnabled = ETrue;
+
+    if (!iAutolockEnabled)
+        SendMessageToSysAp(EEikKeyLockEnabled);
+    iKeyLockCba->MakeVisible(ETrue);
+
+    TBool areWeInIdleState = CEikStatusPaneBase::Current()->PaneCapabilities(TUid::Uid(EEikStatusPaneUidClock)).IsInCurrentLayout();
+        if (areWeInIdleState)
+        { // idle state
+        ((CEikCba*)iKeyLockCba->ButtonGroup())->SetSkinBackgroundId(KAknsIIDQsnBgAreaControlIdle);
+        }
+        else
+            {
+        ((CEikCba*)iKeyLockCba->ButtonGroup())->SetSkinBackgroundId(KAknsIIDQsnBgAreaControl);
+        }
+
+    iEikonEnv->BringForwards(ETrue);
+
+    if ( aShowNote )
+        DisplayLockedNote();
+    ShowKeylockCba();
+    CaptureSystemKeys();
+    iEcsDetector->ConnectToEventSource();
+
+    if ( iNotif )
+        {
+        iNotif->NotifyStatusChange(EKeyLockEnabled);
+        }
+
+    if ( !iSoundsMuted )
+        {
+        CAknAppUiBase* appUi = iAvkonAppUiBase;
+        TRAPD(err, appUi->KeySounds()->PushContextL(R_AVKON_SILENT_SKEY_LIST));
+        if ( !err )
+            {
+            appUi->KeySounds()->BringToForeground();
+            appUi->KeySounds()->LockContext();
+            iSoundsMuted = ETrue;
+            }
+        }
+    }
+
+void CAknKeyLockControl::DisableKeylock()
+    {
+    if ( iSoundsMuted )
+        {
+        CAknAppUiBase* appUi = iAvkonAppUiBase;
+        appUi->KeySounds()->ReleaseContext();
+        appUi->KeySounds()->PopContext();
+        }
+
+    iEcsDetector->CloseEventSource();
+    UnCaptureSystemKeys();
+    iEikonEnv->BringForwards(EFalse);
+    iKeyLockCba->ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(ECoeWinPriorityNeverAtFront);
+    iKeyLockCba->MakeVisible(EFalse);
+    iKeyLockEnabled = EFalse;
+    if (!iAutolockEnabled)
+        SendMessageToSysAp(EEikKeyLockDisabled);
+    if ( iNotif )
+        {
+        iNotif->NotifyStatusChange(EKeyLockDisabled);
+        }
+    iAutolockEnabled = EFalse;
+    }
+
+void CAknKeyLockControl::SendMessageToSysAp(TInt aMessage)
+    {
+    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);
+        }
+    }
+
+void CAknKeyLockControl::OfferKeylock()
+    {
+    iOfferLockNote->ShowNote((CAknNoteDialog::TTimeout)KAknOfferKeyLockTimeout, CAknNoteDialog::ENoTone);
+    iOfferLockEnabled = ETrue;
+    }
+
+
+void CAknKeyLockControl::DisplayLockedNote()
+    {
+    if ( !iAutolockEnabled )
+        {
+    iKeypadLockedNote->ShowNote(CAknNoteDialog::EShortTimeout,CAknNoteDialog::ENoTone);
+#ifdef __COVER_DISPLAY
+#ifdef __SERIES60_30__ // different code for 3.0 and 2.8
+        SAknKeyguardNotePS params;
+        params.iIsLocked = ETrue;
+        params.iTimeout = CAknNoteDialog::EShortTimeout;
+        params.iTone = CAknNoteDialog::ENoTone;
+        TRAP_IGNORE( AknPublishToCoverUI::PublishKeyguardNoteL( params ) );
+#else // 2.8
+        SAknKeyguardNotePSParams params;
+        params.iIsLocked = ETrue;
+        params.iTimeout = CAknNoteDialog::EShortTimeout;
+        TRAP_IGNORE( AknPublishToCoverUI::PublishKeyguardNoteL( params ) );
+#endif // __SERIES60_30__
+#endif // __COVER_DISPLAY
+        }
+    }
+
+void CAknKeyLockControl::DisplayKeyActiveNote()
+    {
+    if ( !iAutolockEnabled )
+        {
+    iKeypadUnlockedNote->ShowNote(CAknNoteDialog::EShortTimeout,CAknNoteDialog::ENoTone);
+#ifdef __COVER_DISPLAY
+#ifdef __SERIES60_30__ // different code for 3.0 and 2.8
+        SAknKeyguardNotePS params;
+        params.iIsLocked = EFalse;
+        params.iTimeout = CAknNoteDialog::EShortTimeout;
+        params.iTone = CAknNoteDialog::ENoTone;
+        TRAP_IGNORE( AknPublishToCoverUI::PublishKeyguardNoteL( params ) );
+#else // 2.8
+        SAknKeyguardNotePSParams params;
+        params.iIsLocked = EFalse;
+        params.iTimeout = CAknNoteDialog::EShortTimeout;
+        TRAP_IGNORE( AknPublishToCoverUI::PublishKeyguardNoteL( params ) );
+#endif // __COVER_DISPLAY
+#endif // __COVER_DISPLAY
+        }
+    }
+
+void CAknKeyLockControl::DoUnlock()
+    {
+    DisableKeylock();
+    DisplayKeyActiveNote();
+    }
+
+void CAknKeyLockControl::ProcessCommandL(TInt aCommandId)
+    {
+    if ( aCommandId == KKeyLockControlAnyKey )
+        {
+        if ( !iPhoneQueryOnScreen )
+            {
+            iPhoneQueryOnScreen = ETrue;
+
+            // show phone query
+            ShowLockPhoneQueryL();
+            }
+        }
+    else if (aCommandId == EAknSoftkeyUnlock)
+        {
+        iPhoneQueryOnScreen = EFalse;
+        if ( iAutolockEnabled )
+            {
+            TApaTaskList aList(iCoeEnv->WsSession());
+            TApaTask aTask = aList.FindApp(TUid::Uid(0x100059B5));
+            if ( aTask.Exists() )
+                {
+                DisableKeylock();
+                iNotif->NotifyStatusChange(EHideSoftNotifications);
+                TKeyEvent keyEvent;
+                keyEvent.iCode = EKeyBell;
+                aTask.SendKey(keyEvent);
+                SendMessageToSysAp(EEikKeyLockPowerKeyPressed);
+                }
+            // else we do nothing, Autolock application was not ready yet.
+            }
+        else
+            {
+            if ( iFeatureKeypadNoSlider )
+                {
+                //Show note "Now press *".
+                //Note is shown when user has pressed "Unlock" when keypad is in locked state
+                iConfirmationNoteAsterisk->ShowNote(
+                    CAknNoteDialog::EShortTimeout,CAknNoteDialog::EConfirmationTone);
+                }
+            else
+                {
+                iConfirmationNote->ShowNote(
+                    CAknNoteDialog::EShortTimeout,CAknNoteDialog::EConfirmationTone);
+                }
+            iUnlockConfirmation = ETrue;
+            }
+        }
+    else if (aCommandId == EAknSoftkeyLock)
+        {
+        // Lock keys
+        DoExitOfferKeylock();
+        EnableKeylock();
+        }
+    else if (aCommandId == EAknSoftkeyExit)
+        {
+        // Cancel offer keylock CBA
+        DoExitOfferKeylock();
+        }
+    else if (aCommandId == EAknSoftkeyEmpty)
+        {
+        if (iKeyLockEnabled)
+            {
+            ShowLockedNote();
+            }
+        }
+    else if (aCommandId == KNoteCmdFocusLost)
+        {
+        // Locked note has become unfocusd - get rid of it
+        if (iOfferLockEnabled)
+            {
+            DoExitOfferKeylock();
+            }
+        }
+    }
+
+TInt CAknKeyLockControl::CountComponentControls() const
+    {
+    if (iKeyLockEnabled)
+        return 1;
+    else
+        return 0;
+    }
+
+CCoeControl* CAknKeyLockControl::ComponentControl(TInt /*aIndex*/) const
+    {
+    if (iKeyLockEnabled)
+        return iKeyLockCba;
+    else
+        return NULL;
+    }
+
+
+TKeyResponse CAknKeyLockControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+    {
+    if (!iOfferLockEnabled && !iKeyLockEnabled)
+        return EKeyWasNotConsumed;
+
+
+    if ( (aType == EEventKey && aKeyEvent.iRepeats == 0) ||
+         (aType == EEventKeyDown && aKeyEvent.iScanCode == EStdKeyDevice2) // Power key
+         )
+        {
+        // If power key pressed, tell SysAp about if
+        if(aKeyEvent.iScanCode == EStdKeyDevice2)
+            {
+            SendMessageToSysAp(EEikKeyLockPowerKeyPressed);
+            }
+
+        if (iOfferLockEnabled)
+            {
+            switch (aKeyEvent.iCode)
+                {
+                case EKeyOK:
+                    {
+                    DoExitOfferKeylock();
+                    EnableKeylock();
+                    }
+                case EKeyLeftArrow:
+                case EKeyRightArrow:
+                case EKeyUpArrow:
+                case EKeyDownArrow:
+                case EKeyApplication:
+                    return EKeyWasConsumed;
+                    break;
+                default:
+            // Normal response - send it to the cba via the control stack
+            return EKeyWasNotConsumed;
+                }
+            }
+        else if (iKeyLockEnabled)
+            {
+            if (iLockedNoteDisplayed)
+                {
+                // See if 'Unlock' has been pressed
+                if (aKeyEvent.iCode == EKeyCBA1)
+                    {
+                    if ( iFeatureKeypadNoSlider )
+                        {
+                        iConfirmationNoteAsterisk->ShowNote(
+                            CAknNoteDialog::EShortTimeout,
+                            CAknNoteDialog::EConfirmationTone);
+                        }
+                    else
+                        {
+                        iConfirmationNote->ShowNote(
+                            CAknNoteDialog::EShortTimeout,
+                            CAknNoteDialog::EConfirmationTone);
+                        }
+
+                    iUnlockConfirmation = ETrue;
+                    iLockedNote->CancelNote();
+                    }
+                // Locked note is on-screen - discard key
+                return EKeyWasConsumed;
+                }
+            else if (iUnlockConfirmation)
+                {
+                // Confirmation note is on-screen - check for OK
+
+                if ( ( aKeyEvent.iCode == KAknAsterisk && iFeatureKeypadNoSlider )
+                  || ( aKeyEvent.iCode == EKeyCBA2 && !iFeatureKeypadNoSlider ) )
+                    {
+                    DoUnlock();
+                    if ( iFeatureKeypadNoSlider )
+                        {
+                        //Show note "Now press *".
+                        //Note is shown when user has pressed "Unlock" when keypad is in locked state
+                        iConfirmationNoteAsterisk->CancelNote();
+                        }
+                    else
+                        {
+                        iConfirmationNote->CancelNote();
+                        }
+                    }
+                else
+                    {
+                    if ( aKeyEvent.iCode != EKeyCBA1 )
+                        ShowLockedNote();
+                    }
+                }
+            else
+                {
+                // Normal response - send it to the cba
+                TKeyResponse cbaResponse = iKeyLockCba->ButtonGroup()->
+                    AsControl()->OfferKeyEventL(aKeyEvent, aType);
+
+                if (cbaResponse == EKeyWasNotConsumed)
+                    {
+                    if ( !iFeatureKeypadNoSlider )
+                        {
+                        // Selection key causes same action as 'Unlock'
+                        if (aKeyEvent.iCode == EKeyOK)
+                            {
+                            iConfirmationNote->ShowNote(
+                                CAknNoteDialog::EShortTimeout,
+                                CAknNoteDialog::EConfirmationTone);
+
+                            iUnlockConfirmation = ETrue;
+                            }
+                        else
+                            {
+                            ShowLockedNote();
+                            }
+                        }
+                    else
+                        {
+                        if ( !(iEcsNote->iNoteOnScreen && aKeyEvent.iCode == EKeyYes) )
+                            {
+                            if ( !iAutolockEnabled )
+                                {
+                                ShowLockedNote();
+                                }
+                            else
+                                {
+                                if(aKeyEvent.iScanCode == EStdKeyDevice2)
+                                    {
+                                    SendMessageToSysAp(EEikKeyLockPowerKeyPressed);
+                                    return EKeyWasConsumed;
+                                    }
+                                switch ( aKeyEvent.iCode )
+                                    {
+                                    case EKeyLeftArrow:
+                                    case EKeyRightArrow:
+                                    case EKeyUpArrow:
+                                    case EKeyDownArrow:
+                                    case EKeyApplication:
+                                    case EKeyCamera:
+                                    case EKeyVolumeUp:
+                                    case EKeyVolumeDown:
+                                    case EKeySide:
+                                        return EKeyWasConsumed;
+                                    case EKeyOK:
+                                    case EKeyPhoneSend:
+                                    case EKeyPhoneEnd:
+                                    case EKeyBackspace:
+                                        if ( !iPhoneQueryOnScreen )
+                                        {
+                                            return EKeyWasConsumed;
+                                        }
+                                    default:
+                                        break;
+                                    }
+                                if ( iPhoneQueryOnScreen )
+                                    {
+                                    return EKeyWasNotConsumed;
+                                    }
+
+                                iPhoneNumber.Zero();
+                                if (aKeyEvent.iScanCode == EStdKeyHash)
+                                    {
+                                    iPhoneNumber.Append( KAknHash );
+                                    }
+                                else
+                                    {
+                                    iPhoneNumber.Append( aKeyEvent.iScanCode );
+                                    }
+                                ProcessCommandL( KKeyLockControlAnyKey );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    return EKeyWasConsumed;
+    }
+
+
+void CAknKeyLockControl::ShowLockedNote()
+    {
+    if ( !iLockedNoteDisplayed )
+        {
+        DoShowLockedNote();
+        }
+    }
+
+
+void CAknKeyLockControl::DoShowLockedNote()
+    {
+    if ( !iAutolockEnabled )
+        {
+        iLockedNote->ShowNote(CAknNoteDialog::EShortTimeout,CAknNoteDialog::ENoTone);
+        iLockedNoteDisplayed = ETrue;
+        }
+    }
+
+void CAknKeyLockControl::ShowKeylockCba()
+    {
+    RDrawableWindow* cbaWindow = iKeyLockCba->ButtonGroup()->AsControl()->DrawableWindow();
+    cbaWindow->SetFaded(EFalse, RWindowTreeNode::EFadeWindowOnly);
+    cbaWindow->SetOrdinalPosition(0,1);
+    cbaWindow->SetNonFading(ETrue);
+    }
+
+void CAknKeyLockControl::CaptureSystemKeys()
+    {
+    if (!iKeysCaptured)
+        {
+        RWindowGroup& groupWin=iCoeEnv->RootWin();
+        iAppKey = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication0, 0, 0); // Capture app key
+        iPowerKey = groupWin.CaptureKeyUpAndDowns(EStdKeyDevice2, 0, 0);      // Capture power key
+        iVoiceKey = groupWin.CaptureKeyUpAndDowns(EStdKeyDevice6, 0, 0);      // Capture power key
+        iAppKey2 = groupWin.CaptureKey(EKeyApplication0, 0, 0); // Capture app key
+        iPowerKey2 = groupWin.CaptureKey(EKeyDevice2, 0, 0);      // Capture power key
+        iVoiceKey2 = groupWin.CaptureKey(EKeyDevice6, 0, 0);      // Capture power key
+        iLeftSoftKey = groupWin.CaptureKey(EKeyDevice0,0,0);
+        iEditKey = groupWin.CaptureKey(EKeyRightShift,0,0);
+        iCameraKey = groupWin.CaptureKeyUpAndDowns(EKeyCamera,0,0);
+        iVolumeUpKey = groupWin.CaptureKeyUpAndDowns(EStdKeyIncVolume,0,0);
+        iVolumeDownKey = groupWin.CaptureKeyUpAndDowns(EStdKeyDecVolume,0,0);
+        iCameraKey2 = groupWin.CaptureKey(EKeyDevice7,0,0);
+        iVolumeUpKey2 = groupWin.CaptureKey(EKeyVolumeUp,0,0);
+        iVolumeDownKey2 = groupWin.CaptureKey(EKeyVolumeDown,0,0);
+        iKeysCaptured = ETrue;
+        }
+    }
+
+void CAknKeyLockControl::UnCaptureSystemKeys()
+    {
+    if (iKeysCaptured)
+        {
+        RWindowGroup& groupWin=iCoeEnv->RootWin();
+        groupWin.CancelCaptureKeyUpAndDowns(iAppKey);
+        groupWin.CancelCaptureKeyUpAndDowns(iPowerKey);
+        groupWin.CancelCaptureKeyUpAndDowns(iVoiceKey);
+        groupWin.CancelCaptureKey(iAppKey2);
+        groupWin.CancelCaptureKey(iPowerKey2);
+        groupWin.CancelCaptureKey(iVoiceKey2);
+        groupWin.CancelCaptureKey(iLeftSoftKey);
+        groupWin.CancelCaptureKey(iEditKey);
+        groupWin.CancelCaptureKey(iCameraKey);
+        groupWin.CancelCaptureKey(iVolumeUpKey);
+        groupWin.CancelCaptureKey(iVolumeDownKey);
+        groupWin.CancelCaptureKey(iCameraKey2);
+        groupWin.CancelCaptureKey(iVolumeUpKey2);
+        groupWin.CancelCaptureKey(iVolumeDownKey2);
+        iKeysCaptured = EFalse;
+        }
+    }
+
+void CAknKeyLockControl::HandleEcsEvent( CAknEcsDetector* aEcsDetector, CAknEcsDetector::TState aState )
+    {
+    switch ( aState )
+        {
+        case CAknEcsDetector::ECompleteMatchThenSendKey:
+            // Do nothing since note will be removed on ECallAttempted event
+            break;
+        case CAknEcsDetector::ECompleteMatch:
+            if ( !iPhoneQueryOnScreen )
+                {
+                iEcsNote->SetEmergencyNumber( aEcsDetector->CurrentMatch() );
+                iEcsNote->ShowNote( CAknNoteDialog::ENoTimeout,CAknNoteDialog::ENoTone );
+
+                // Tell sysAp to switch lights on
+                SendMessageToSysAp(EEikKeyLockPowerKeyPressed);
+                iEcsNote->iNoteOnScreen =ETrue;
+                }
+            break;
+        case CAknEcsDetector::EPartialMatch:
+            iEcsNote->SleepNote();
+            break;
+        case CAknEcsDetector::ECallAttempted:
+            iEcsNote->SleepNote();
+            break;
+        case CAknEcsDetector::EEmpty:
+            iEcsNote->SleepNote();
+            break;
+        case CAknEcsDetector::ENoMatch:
+            iEcsNote->SleepNote();
+            break;
+        default:
+            break;
+        }
+
+    }
+
+void CAknKeyLockControl::DoExitOfferKeylock()
+    {
+    iOfferLockNote->CancelNote();
+    }
+
+void CAknKeyLockControl::OfferTimerExpired()
+    {
+    DoExitOfferKeylock();
+    }
+
+void CAknKeyLockControl::AutolockEnabled(TBool aAutoLockOn)
+    {
+    iAutolockEnabled = aAutoLockOn;
+    }
+
+void CAknKeyLockControl::CallNumberL( TDesC& aNumber )
+    {
+    CAiwServiceHandler* serviceHandler;
+    serviceHandler = CAiwServiceHandler::NewL();
+    serviceHandler->AttachL(R_AKNNOTIFYPLUGIN_INTEREST);
+
+    TAiwDialDataV1 dialData = TAiwDialDataV1();
+    dialData.SetTelephoneNumber(aNumber);
+    dialData.SetCallType(EAiwVoice);
+    TAiwDialDataV1Pckg dialDataPckg = TAiwDialDataV1Pckg(dialData);
+    CAiwGenericParamList& paramList = serviceHandler->InParamListL();
+    TPtrC8 ptr;
+    ptr.Set(dialDataPckg);
+    TAiwVariant variant(ptr);
+    TAiwGenericParam param(EGenericParamCallDialDataV1, variant);
+    paramList.AppendL(param);
+
+    serviceHandler->ExecuteServiceCmdL(KAiwCmdCall,
+                                        paramList,
+                                        serviceHandler->OutParamListL(),
+                                        0,
+                                        NULL);
+    }
+
+void CAknKeyLockControl::ShowLockPhoneQueryL()
+    {
+    iKeyLockCba->MakeVisible(EFalse);
+
+    HBufC* phoneNumber = HBufC::NewLC(KPhoneNumberMaxLength);
+    phoneNumber->Des() = iPhoneNumber;
+    TPtr phonePtr(phoneNumber->Des());
+
+    CAknLockedPhoneQuery* phoneQuery = CAknLockedPhoneQuery::NewL(phonePtr);
+    TInt queryAction = phoneQuery->ExecuteLD(R_AVKON_LOCK_PHONE_QUERY);
+    switch(queryAction)
+        {
+        case EAknSoftkeyCall:
+            CallNumberL(phonePtr);
+            break;
+        default:
+            break;
+        }
+
+    iPhoneQueryOnScreen = EFalse;
+    CleanupStack::PopAndDestroy(phoneNumber);
+
+    iKeyLockCba->MakeVisible(ETrue);
+    }
+
+// CAknKeyLockNotifierSubject
+
+CAknKeyLockNotifierSubject* CAknKeyLockNotifierSubject::NewL()
+    {
+    CAknKeyLockNotifierSubject* self = new(ELeave)CAknKeyLockNotifierSubject();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+
+void CAknKeyLockNotifierSubject::ConstructL()
+    {
+    CCoeEnv* environment = CCoeEnv::Static();
+
+    TFileName resourceFile;
+    resourceFile.Append(KRESOURCEFILE);
+    BaflUtils::NearestLanguageFile(environment->FsSession(),resourceFile);
+
+    iResourceFileOffset = environment->AddResourceFileL(resourceFile);
+
+    iObserverList = new(ELeave)CArrayPtrFlat<MAknKeyLockObserver>(KAknObserverListGranularity);
+    iKeyLockControl = new(ELeave)CAknKeyLockControl(this);
+    iKeyLockControl->ConstructL();
+    // Make sure AppUi has a pointer to this
+    STATIC_CAST(CEikServAppUi*,CEikonEnv::Static()->AppUi())->iKeyLockController = this;
+    }
+
+CAknKeyLockNotifierSubject::CAknKeyLockNotifierSubject()
+:iAllowNotifications(ETrue)
+    {
+    }
+
+
+CAknKeyLockNotifierSubject::~CAknKeyLockNotifierSubject()
+    {
+    if ( iResourceFileOffset )
+        CCoeEnv::Static()->DeleteResourceFile(iResourceFileOffset);
+    delete iKeyLockControl;
+    delete iObserverList;
+    }
+
+void CAknKeyLockNotifierSubject::Release()
+    {
+    delete this;
+    }
+
+CAknKeyLockNotifierSubject::TNotifierInfo CAknKeyLockNotifierSubject::RegisterL()
+    {
+    iInfo.iUid=KAknKeyLockNotifierUid;
+    iInfo.iChannel=EAknNotifierChannelKeyLock;
+    iInfo.iPriority=ENotifierPriorityHigh;
+    return iInfo;
+    }
+
+CAknKeyLockNotifierSubject::TNotifierInfo CAknKeyLockNotifierSubject::Info() const
+    {
+    return iInfo;
+    }
+
+TPtrC8 CAknKeyLockNotifierSubject::StartL(const TDesC8& aBuffer)
+    {
+    SAknNotifierPackage<SAknKeyLockNotifierParams>* params
+        = ( SAknNotifierPackage<SAknKeyLockNotifierParams>*)aBuffer.Ptr();
+
+    if ( aBuffer.Length() < 0 || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage<SAknKeyLockNotifierParams>)
+        || params->iSignature != KAKNNOTIFIERSIGNATURE )
+        {
+        User::Leave( KErrArgument );
+        }
+
+    switch (params->iParamData.iReason)
+        {
+        case ELockEnabled:
+        case ELockDisabled:
+        case EAllowNotifications:
+        case EStopNotifications:
+        case EOfferKeylock:
+        case ECancelAllNotifications:
+        case EEnableAutoLockEmulation:
+        case EDisableWithoutNote:
+        case EEnableWithoutNote:
+            break;
+        case EInquire:
+            {
+            iRetPckg().iEnabled = IsKeyLockEnabled();
+            }
+        default:
+            break;
+        }
+    return iRetPckg;
+    }
+
+void CAknKeyLockNotifierSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)
+    {
+    SAknNotifierPackage<SAknKeyLockNotifierParams>* params
+        = ( SAknNotifierPackage<SAknKeyLockNotifierParams>*)aBuffer.Ptr();
+
+    if ( aBuffer.Length() < 0 || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage<SAknKeyLockNotifierParams>)
+        || params->iSignature != KAKNNOTIFIERSIGNATURE )
+        {
+        User::Leave( KErrArgument );
+        }
+
+    switch (params->iParamData.iReason)
+        {
+        case ELockEnabled:
+            DoEnableKeyLock();
+            break;
+        case ELockDisabled:
+            DoDisableKeyLock();
+            break;
+        case EAllowNotifications:
+            DoAllowNotifications();
+            break;
+        case EStopNotifications:
+            DoStopNotifications();
+            break;
+        case EOfferKeylock:
+            DoOfferKeyLock();
+            break;
+        case ECancelAllNotifications:
+            DoCancelAllNotificatons();
+            break;
+        case EEnableAutoLockEmulation:
+            NotifyStatusChange(EShowSoftNotifications);
+            LockKeys(ETrue);
+            break;
+        case EDisableWithoutNote:
+            UnlockKeys();
+            break;
+        case EEnableWithoutNote:
+            if (!IsKeyLockEnabled())
+                {
+                iKeyLockControl->EnableKeylock(EFalse);
+                }
+            break;
+        case ECommandFSWToHideApplication:
+            {
+            TInt uid(0);
+            TBool disable(EFalse);
+            RDesReadStream readStream(aBuffer);
+            readStream.ReadInt32L(); // signature
+            readStream.ReadInt32L(); // op
+            uid = readStream.ReadInt32L(); // uid
+            disable = readStream.ReadInt32L(); // enable / disable
+            STATIC_CAST(CEikServAppUi*,CEikonEnv::Static()->AppUi())->HideApplicationFromFswL(uid,disable);
+            }
+            break;
+        default:
+            break;
+        };
+
+    aMessage.Complete(KErrNone);
+    }
+
+void CAknKeyLockNotifierSubject::Cancel()
+    {
+    }
+
+TPtrC8 CAknKeyLockNotifierSubject::UpdateL(const TDesC8& aBuffer)
+    {
+    return TPtrC8(aBuffer);
+    }
+
+
+
+TBool CAknKeyLockNotifierSubject::IsKeyLockEnabled()
+    {
+    return iKeyLockControl->iKeyLockEnabled;
+    }
+
+TBool CAknKeyLockNotifierSubject::AllowNotifications()
+    {
+    return iAllowNotifications;
+    }
+
+
+
+void CAknKeyLockNotifierSubject::UnlockKeys()
+    {
+    if (IsKeyLockEnabled())
+        {
+        iKeyLockControl->DisableKeylock();
+        }
+    }
+
+void CAknKeyLockNotifierSubject::LockKeys(TBool aAutoLockOn)
+    {
+
+    // Well have to disable keylock if we are changing autolock status
+    if ( iKeyLockControl->iKeyLockEnabled &&
+        aAutoLockOn != iKeyLockControl->iAutolockEnabled )
+        {
+        iKeyLockControl->DisableKeylock();
+        }
+
+    if (!IsKeyLockEnabled())
+        {
+        iKeyLockControl->AutolockEnabled(aAutoLockOn);
+
+        iKeyLockControl->EnableKeylock();
+        }
+    }
+
+
+void CAknKeyLockNotifierSubject::AddObserverL(MAknKeyLockObserver* aObserver)
+    {
+#if defined(_DEBUG)
+    TInt count = iObserverList->Count();
+    for (TInt ii=0; ii<count; ii++)
+        {
+        if ( ((*iObserverList)[ii]) == aObserver)
+            {
+            Panic(EAknPanicKeyLockObserverAlreadyExists);
+            }
+        }
+#endif
+    iObserverList->AppendL(aObserver);
+
+    // Make sure that the observer isn't obscuring the keylock CBA
+    ShowKeylockCba();
+    }
+
+
+void CAknKeyLockNotifierSubject::RemoveObserver(MAknKeyLockObserver* aObserver)
+    {
+    TInt count = iObserverList->Count();
+    for (TInt ii=0; ii<count; ii++)
+        {
+        if ( ((*iObserverList)[ii]) == aObserver)
+            {
+            iObserverList->Delete(ii);
+            return;
+            }
+        }
+#if defined(_DEBUG)
+    Panic(EAknPanicKeyLockObserverNotFound);
+#endif
+    }
+
+
+void CAknKeyLockNotifierSubject::ShowKeylockCba()
+    {
+    if (iKeyLockControl->iKeyLockEnabled)
+        {
+        iKeyLockControl->ShowKeylockCba();
+        }
+    }
+
+void CAknKeyLockNotifierSubject::NotifyStatusChange(TKeyLockStatus aStatus)
+    {
+    TInt count = iObserverList->Count();
+    for (TInt ii=count-1; ii>=0; ii--)
+        {
+        ((*iObserverList)[ii])->KeyLockStatusChange(aStatus);
+        }
+    }
+
+void CAknKeyLockNotifierSubject::DoAllowNotifications()
+    {
+    TBool lastvalue = iAllowNotifications;
+    iAllowNotifications = ETrue;
+    NotifyStatusChange(EKeyLockAllowNotifications);
+    if (!lastvalue)
+        {
+        CEikonEnv* env = CEikonEnv::Static();
+        // To prevent this being called more than once
+        env->SetAutoForwarding(ETrue);
+        while (iActiveWindowCount)
+            {
+            env->BringForwards(ETrue);
+            iActiveWindowCount--;
+            }
+        env->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront);
+        env->BringForwards(ETrue);
+        env->BringForwards(EFalse);
+
+        // Enable FSW
+        STATIC_CAST(CEikServAppUi*,env->AppUi())->SuppressAppSwitching(EFalse);
+        }
+    }
+
+void CAknKeyLockNotifierSubject::DoStopNotifications()
+    {
+    TBool lastvalue = iAllowNotifications;
+    iAllowNotifications = EFalse;
+    NotifyStatusChange(EKeyLockStopNotifications);
+    if (lastvalue)
+        {
+        // To prevent this being called more than once
+        // Count number of times BringForwards is needed to make EikSrvUi go to background
+        iActiveWindowCount = 0;
+        CEikonEnv* env = CEikonEnv::Static();
+        TInt windowId = env->RootWin().Identifier();
+        while (env->WsSession().GetWindowGroupOrdinalPriority(windowId) > 0)
+            {
+            iActiveWindowCount++;
+            env->BringForwards(EFalse);
+            }
+        env->SetAutoForwarding(EFalse);
+        STATIC_CAST(CEikServAppUi*,env->AppUi())->SuppressAppSwitching(ETrue);
+        }
+    }
+
+void CAknKeyLockNotifierSubject::DoCancelAllNotificatons()
+    {
+    // Used when end key is pressed, to allow phone app to cancel all
+    // notifications. Global notes / soft notifications that would
+    // not normally be shown (out of priority) are not cancelled
+
+    if ( IsKeyLockEnabled() )
+        {
+        return;
+        }
+
+    NotifyStatusChange(EKeyLockCancelNotification);
+
+    // Send cancel key event to all other notifications, and hope they cancel
+
+    TRAPD(err, AknDialogShutter::ShutDialogsL(*CEikonEnv::Static()));
+    // Ignore error message - there's nothing more we can do
+    }
+
+
+
+void CAknKeyLockNotifierSubject::DoEnableKeyLock()
+    {
+    if (!IsKeyLockEnabled())
+        {
+        iKeyLockControl->EnableKeylock();
+        }
+    }
+
+void CAknKeyLockNotifierSubject::DoDisableKeyLock()
+    {
+    if (IsKeyLockEnabled())
+        {
+        iKeyLockControl->DisableKeylock();
+        // Attempt to display KeyActive note
+        iKeyLockControl->DisplayKeyActiveNote();
+        }
+    else if (iKeyLockControl->iOfferLockEnabled)
+        {
+        // Remove the offer key lock CBA
+        iKeyLockControl->OfferTimerExpired();
+        }
+    }
+
+
+void CAknKeyLockNotifierSubject::DoOfferKeyLock()
+    {
+    if (!IsKeyLockEnabled())
+        {
+        NotifyStatusChange(EKeyLockOffered);
+        iKeyLockControl->OfferKeylock();
+        }
+    }