/*

* Copyright (c) 2000-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".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Implementation of terminalsecurity components

*

*/

#include <AknQueryDialog.h>

#include "SCPQueryDialog.h"

#include <eikseced.h>

#include <aknsoundsystem.h>

#include <StringLoader.h>

#include <aknappui.h> 

#include <avkon.rsg>

// Include the SecUi definitions

#include <secui.hrh>

#include "SCPDebug.h"

// For Central Repository

#include <centralrepository.h>

#include <AknIncallBubbleNotify.h>

#include <e32property.h>

#include <ctsydomainpskeys.h>

#include "SCPCodePrivateCRKeys.h"

#include <DevManInternalCRKeys.h>

#include <featmgr.h>

/*#ifdef _DEBUG

#define __SCP_DEBUG

#endif // _DEBUG

// Define this so the precompiler in CW 3.1 won't complain about token pasting,

// the warnings are not valid

#pragma warn_illtokenpasting off

#ifdef __SCP_DEBUG

#define Dprint(a) RDebug::Print##a

#else

#define Dprint(a)

#endif // _DEBUG*/

const TInt KSCPSpecialDeleteEvent( 63529 );

const TInt KLockedbyLawmo (30);

// ================= MEMBER FUNCTIONS =======================

//

// ----------------------------------------------------------

// CSCPQueryDialog::CSCPQueryDialog()

// C++ constructor

// ----------------------------------------------------------

//

CSCPQueryDialog::CSCPQueryDialog(   TDes& aDataText,

                                    RSCPClient::TSCPButtonConfig aButtonsShown, 

                                    TInt aMinLength,

                                    TInt aMaxLength,

                                    TBool aECSSupport,

                                    TKeypadContext aContextSensitive /*= EContextSensitive*/

                                    )

            : CAknTextQueryDialog(aDataText, ENoTone),

			  iMinLength(aMinLength),

			  iMaxLength(aMaxLength),

			  iValidTextLen( 0 ),

			  iButtons( aButtonsShown ),

			  iECSSupport( aECSSupport ),

			  iEcsDetector( NULL ),

			  iEMCallActivated( EFalse ),

			  iShowingEMNumber( EFalse ),

			  iPreviousCharacterWasInvalid( EFalse ),

			  iPrioritySet( EFalse ),

			  iPriorityDropped( EFalse ),

			  iLockedByLawMo( EFalse ),

			  iKeyUsed ( NULL ),

			  iContextSensitive(aContextSensitive)

	{

        def_mode = 0;

        iAppKey = 0;

        iMode = KSCPModeNormal;

	}

//

// ----------------------------------------------------------

// CSCPQueryDialog::~CSCPQueryDialog()

// Destructor

// ----------------------------------------------------------

//

CSCPQueryDialog::~CSCPQueryDialog()

	{

	Dprint( (_L("CSCPQueryDialog::~CSCPQueryDialog()")) );

   if (iDeviceLockStatusObserver)

        delete iDeviceLockStatusObserver;

    if (iCallStatusObserver)

        delete iCallStatusObserver;

	if (iFront)

		{

		// Uncapture keys, if they were captured

		if ( iMode == KSCPModeRestricted )		

			{

			RWindowGroup& groupWin=iCoeEnv->RootWin();

			groupWin.CancelCaptureKeyUpAndDowns(iAppKey);

			groupWin.CancelCaptureKeyUpAndDowns(iVoiceKey2);

			groupWin.CancelCaptureKey(iVoiceKey1);

			}

		if ( iPrioritySet )

		    {

    		// Return normal high-priority in case there are other notifiers active 

	    	// and were are not going to lose foregroung right after following call	

		    iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront);

		    }

		iEikonEnv->BringForwards(EFalse);	

		iEikonEnv->EikAppUi()->RemoveFromStack(this);

		static_cast<CAknAppUi*>(iEikonEnv->EikAppUi())->KeySounds()->ReleaseContext();

		static_cast<CAknAppUi*>(iEikonEnv->EikAppUi())->KeySounds()->PopContext();

		if ( iECSSupport )

            {

		    delete iEcsDetector;

            }

		iFront = EFalse;

		}

}

void CSCPQueryDialog :: PostLayoutDynInitL() {

    Dprint( (_L("[CSCPQueryDialog]-> PostLayoutDynInitL() >>>") ));    

    iDeviceLockStatusObserver = CSCPLockObserver::NewL(this);

    iCallStatusObserver = CSCPLockObserver::NewL(this, ESecUiCallStateObserver);

    Dprint( (_L("[CSCPQueryDialog]-> PostLayoutDynInitL() <<<") ));

}

//

// ----------------------------------------------------------

// CSCPQueryDialog::PreLayoutDynInitL()

// Called by framework before dialog is shown 

// ----------------------------------------------------------

//

void CSCPQueryDialog :: PreLayoutDynInitL()

    {

    Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL()") ));

    CAknTextQueryDialog::PreLayoutDynInitL();

    CEikSecretEditor* queryControl = static_cast<CEikSecretEditor*>( 

                QueryControl()->ControlByLayoutOrNull( QueryControl()->QueryType() ) );

    queryControl->SetFeature(CEikSecretEditor::ELockQuerySCT, ETrue);

    //disable in call bubble.

    if ( AknLayoutUtils::PenEnabled() )

        {

        SetIncallBubbleAllowedInUsualL( EFalse );

        }

    // Create the ECS detector object if required

    if ( iECSSupport )

        {

        Dprint( (_L(" Creating ECS detector") ));

        iEcsDetector = CAknEcsDetector::NewL();

        iEcsDetector->SetObserver( this );

        }    

    Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): Set input mode") ));

    switch(iContextSensitive) {

        case EContextSensitive: {

            Dprint(_L("[CSCPQueryDialog]-> iContextSensitive = EContextSensitive"));

            /* The default input mode of the lock code query must be set on the basis of the

            very first character of the current lock code. If the first character of the current

            lock code is numeric, the default input mode will also be numeric. Otherwise, the 

            default input mode will be alphabetic */

            CRepository* repository = CRepository :: NewL(KCRUidSCPParameters);

            CleanupStack :: PushL(repository);

            User :: LeaveIfError(repository->Get(KSCPLockCodeDefaultInputMode, def_mode));            

            CleanupStack :: PopAndDestroy(repository);

            if (def_mode == 0) {

                Dprint(_L("[CSCPQueryDialog]-> Context determined as Numeric"));

                SetDefaultInputMode(EAknEditorNumericInputMode);

            }

            else {

                Dprint(_L("[CSCPQueryDialog]-> Context determined as Alphanumeric"));

                SetDefaultInputMode(EAknEditorSecretAlphaInputMode);

            }

        }

        break;

        case ENumeric:

            Dprint(_L("[CSCPQueryDialog]-> iContextSensitive = ENumeric"));

            SetDefaultInputMode( EAknEditorNumericInputMode );

            break;

        case EAlphaNumeric:

            Dprint(_L("[CSCPQueryDialog]-> iContextSensitive = EAlphaNumeric"));

            SetDefaultInputMode( EAknEditorSecretAlphaInputMode );

            break;

    };

    // Set the mode, we use this to determine the functionality for special keys

    if ( ( iButtons == RSCPClient::SCP_OK ) || ( iButtons == RSCPClient::SCP_OK_CANCEL ) )

        {

        // Normal mode

        iMode = KSCPModeNormal;

        }

    else

        {

        // Restricted mode, used for example for Etel-originated queries

        iMode = KSCPModeRestricted;

        }

    Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): Set button config") ));

    // Set the softkey-configuration

    switch ( iButtons )

        {

            case ( RSCPClient::SCP_OK ):

            // Flow through

            case ( RSCPClient::SCP_OK_ETEL ):

                {

                // Hide the Cancel-softkey

                ButtonGroupContainer().MakeCommandVisible( EAknSoftkeyCancel, EFalse );

                break;

                }

            default:

                // Show both softkeys

            break;

        }

	QueryControl()->SetTextEntryLength( iMaxLength ); 

	// Add this higher than the environment filter, otherwise

	// we cannot capture keys from the EikSrvUi KeyFilter. 

	// Used because this query might be called from notifier		

	if ( iMode == KSCPModeNormal )

		{

		iEikonEnv->EikAppUi()->AddToStackL(this,

		                                   ECoeStackPriorityEnvironmentFilter+100,

		                                   ECoeStackFlagRefusesAllKeys);

		}

	else

		{

		iEikonEnv->EikAppUi()->AddToStackL(this,

		                                   ECoeStackPriorityEnvironmentFilter+100,

		                                   ECoeStackFlagRefusesFocus);

		}

	Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): Capture keys") ));

	// Capture app, voice and end keys if necessary

	if ( iMode == KSCPModeRestricted )		

		{		

		RWindowGroup& groupWin=iCoeEnv->RootWin();

		// Capture app key

		iAppKey = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication0, 0, 0);

		// capture voice key

		iVoiceKey1 = groupWin.CaptureKey(EKeySide,0,0);

		iVoiceKey2 = groupWin.CaptureKeyUpAndDowns(EStdKeyDevice6, 0, 0);

		}

    RWsSession& wsSession = iEikonEnv->WsSession();

    TInt myWgId = iEikonEnv->RootWin().Identifier();

    TInt wgPrio = wsSession.GetWindowGroupOrdinalPriority(myWgId);

	Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): wgPrio %d"),wgPrio ));

	TInt var;

	RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, var);

	Dprint((_L("CSCPQueryDialog::PreLayoutDynInitL(): EPSCTsyCallStateNone %d"), var));

    // If the call is made during device startup have the priority as normal

        switch(var) {

            default:

            case EPSCTsyCallStateNone:

                Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): Started Maximized...")));

                iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront + 1);

                iPrioritySet = ETrue;

                break;

            case EPSCTsyCallStateAlerting:

            case EPSCTsyCallStateHold:

            case EPSCTsyCallStateRinging:

            case EPSCTsyCallStateDialling:

            case EPSCTsyCallStateAnswering:

            case EPSCTsyCallStateConnected: {

                switch(iButtons) {

                    case RSCPClient::SCP_OK:

                    case RSCPClient::SCP_OK_ETEL: {

                        Dprint( (_L("CSCPQueryDialog::PreLayoutDynInitL(): Started Minimized...")));

                        iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityLow);

                        break;

                    }

                    default:

                        break;

                }

            }

        }

    }

    TInt currentLawmoState(0); 

    Dprint( (_L("CSCPQueryDialog::lawmo cenrep") ));

    CRepository* crep = CRepository::NewLC( KCRUidDeviceManagementInternalKeys );

    TInt reterr = crep->Get( KLAWMOPhoneLock, currentLawmoState ); 

    Dprint( (_L("CSCPQueryDialog::lawmo cenrep done") ));

    if(reterr != KErrNone) 

        {

        Dprint(_L("[RSCPClient]-> ERROR: Unable to perform get on CenRep lawmo, lErr=%d"), reterr);

        CleanupStack :: PopAndDestroy(crep);

        return;

        }

    if(currentLawmoState!=KLockedbyLawmo)

        {

        // Hide the OK key

        Dprint( (_L("CSCPQueryDialog::lawmo state !=30, dim key") ));

        iLockedByLawMo = ETrue;

        ButtonGroupContainer().MakeCommandVisible( EAknSoftkeyOk, ETrue );

        ButtonGroupContainer().DimCommand(EAknSoftkeyOk, ETrue);

        }	

	CleanupStack::PopAndDestroy();

}

//

// ---------------------------------------------------------

// CSCPQueryDialog::OfferKeyEventL

// called by framework when any key is pressed

// ---------------------------------------------------------

//

TKeyResponse CSCPQueryDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

    Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(%d, %d, %d)"), aKeyEvent.iScanCode, 

        aKeyEvent.iCode, aType ));

    //Handling for Key up events for special characters  

    if (aType == EEventKeyUp && iPriorityDropped && iKeyUsed

            == aKeyEvent.iScanCode)

        {

        DrawableWindow()->SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront);

        ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(

                0, ECoeWinPriorityAlwaysAtFront);

        iPriorityDropped = EFalse;

        iKeyUsed = NULL;

        Dprint((_L("CSCPQueryDialog::OfferKeyEventL(): Priority dropped")));

        return EKeyWasConsumed;

        }

    else

        {

        if (iPriorityDropped && iKeyUsed != aKeyEvent.iScanCode

                && (aKeyEvent.iScanCode == EStdKeyDevice0

                        || aKeyEvent.iScanCode == EStdKeyDevice1

                        || aKeyEvent.iScanCode == EStdKeyDevice2

                        || aKeyEvent.iScanCode == EStdKeyDevice3))

            {

            iPriorityDropped = EFalse;

            iKeyUsed = NULL;

            }

        }

    //Consume the characters which are typed before Key up events of special characters

    if (iPriorityDropped && iKeyUsed != NULL)

        {

        return EKeyWasConsumed;

        }

	// Check if the priority should be dropped, so that special dialogs can be shown

	if ( ( aType == EEventKeyDown ) && 

	     ( ( aKeyEvent.iScanCode == EStdKeyLeftShift ) || // Pen-key

	       ( aKeyEvent.iScanCode == EStdKeyRightShift ) || // Pen-key

	       ( aKeyEvent.iScanCode == EStdKeyLeftFunc )  || //Chr-key

	       ( aKeyEvent.iScanCode == EStdKeyNkpAsterisk ) || // * - key

	       ( aKeyEvent.iScanCode == '*' )                  // * - key

	     )

	   )

	    {

        iKeyUsed = aKeyEvent.iScanCode;

	    DrawableWindow()->SetOrdinalPosition(0,0);

	    ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,0);

	    iPriorityDropped = ETrue;

	    Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(): Priority dropped") ));

	    }

	else

	    {

	    // Return priority, either no dialogs shown, or already exited.

	    if ( iPriorityDropped )

	        {

            DrawableWindow()->SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront);

	        ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront);

	        iPriorityDropped = EFalse;

	        Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(): Priority re-raised") ));

	        }

	    }

    if ( aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter)

        {

            if(QueryControl()->GetTextLength() > 0) {

                // Try to exit with OK as well

                TryExitL(EAknSoftkeyOk);                

            }

            return EKeyWasConsumed;

        }

	// app key

	if (aKeyEvent.iScanCode == EStdKeyApplication0)

		{

		if ( iButtons == RSCPClient::SCP_OK_CANCEL )

			{

			TryExitL(EAknSoftkeyCancel);

			return EKeyWasNotConsumed;	

			}

		return EKeyWasConsumed;

		}

	// end key

	if ( (aKeyEvent.iCode == EKeyPhoneEnd) || (aKeyEvent.iCode == EKeyEscape) )

        {

        if ( ( iButtons == RSCPClient::SCP_OK_CANCEL ) ||  

            ( iButtons == RSCPClient::SCP_OK_CANCEL_ETEL ) )

            {

            TryExitL(EAknSoftkeyCancel);          

            }

        return EKeyWasConsumed;

        }

	if (aKeyEvent.iCode == EKeyPhoneSend)

	    {

        //if (AknLayoutUtils::PenEnabled())

            {

            if (iECSSupport)

                {

                if ( iEcsDetector->State() == CAknEcsDetector::ECompleteMatch ||

                     iEcsDetector->State() == CAknEcsDetector::EServiceNumMatch )

                    {

                    Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(): adding EKeyPhoneSend to detector")));

                    switch(iButtons) {

                        case RSCPClient::SCP_OK:

                        case RSCPClient::SCP_OK_ETEL:

                            //Required only during device startup

                            iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityLow);

                            break;

                        default:

                            break;

                    }

                    iEcsDetector->AddChar( (TText)(EKeyPhoneSend ) );

                    }   

                else

                    {

                    Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(): ShowWarningNoteL") ));

                    ShowWarningNoteL();

                    return EKeyWasConsumed;

                    }

                }

            else //consume the key to prevent dialler from opening

                {

                Dprint( (_L("CSCPQueryDialog::OfferKeyEventL(): EKeyPhoneSend :EKeyWasConsumed") ));

                return EKeyWasConsumed;

                }

            }

        }

    if ( ( aType == EEventKey ) && ( aKeyEvent.iCode == KSCPSpecialDeleteEvent ) )

        {

        // This special event is sent to remove the previous character while "cycling" with

        // the numeric keys. Discard, if the previous character was already removed.

        if ( iPreviousCharacterWasInvalid )

            {

            return EKeyWasConsumed;

            }

        }

    if ( ( aType == EEventKey ) && ( iECSSupport ) )