/*

* Copyright (c) 2001-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 EAP TTLS UI settings dialog

*

*/

/*

*/

// INCLUDE FILES

#include <eikdialg.h>

#include <AknDialog.h>

#include <aknlists.h>

#include "EapTtlsUiView.h"

#include "EapTtlsUi.hrh"

#include <eapttlsui.rsg>

#include <akntextsettingpage.h>

#include <aknsettingitemlist.h>

#include "EapTtlsUiSettingArray.h"

#include <aknnavi.h>

#include <akntabgrp.h>

#include <aknnavide.h>

#include <aknradiobuttonsettingpage.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <EapTlsPeapUiCipherSuites.h>

#include <EapTlsPeapUiEapTypes.h>

#include <EapTlsPeapUiCertificates.h>

#include <EapType.h>

#include <EapTypeInfo.h> 

#include <AknIconArray.h>

#include <AknsUtils.h>

#include <featmgr.h>

#include <hlplch.h>

// CONSTANTS

// UID of general settings app, in which help texts are included

const TUid KHelpUidPlugin = { 0x100058EC };

static const TInt KSettingArrayGranularity = 4;    

static const TInt KSuiteArrayGranularity = 5;

static const TInt KMaxLengthOfEapLine = 270;

static const TInt KCertificateArrayGranularity = 5;

static const TInt KMaxLengthOfSuiteName = 255;

static const TInt KEapTtlsId = 21;

_LIT( KNameSeparator, " " );

_LIT( KEmptyString, "" );

const TUint KFirstElement = 0;

const TUint KSecondElement = 1;

const TUint KMinEnabledCount = 1;

/* This is the maximum length of a certificate's full name, includes

label, primary and secondary names */

const TUint32 KMaxFullCertLabelLength = KMaxCertLabelLength + 2 * 

                                    KMaxNameLength + 1; // 1 is for separator.

// MODULE DATA STRUCTURES

enum TPageIds

    {

    ESettingsPage = 0,

    EEapTypePage,

    ECipherSuitePage

    };

enum TSettingIds

    {

    EUserCertificateItem = 0,

    ECaCertificateItem,

    EUsernameInUseItem,

    EUsernameItem,

    ERealmInUseItem,

    ERealmItem

    };

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

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

// CEapTtlsUiDialog::CEapTtlsUiDialog

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

//

CEapTtlsUiDialog::CEapTtlsUiDialog( CEapTlsPeapUiConnection* aConnection,

                                    TIndexType aIndexType, TInt aIndex, 

								    TInt& aButtonId ) 

: CAknDialog(), 

  iConnection( aConnection ),

  iIndexType( aIndexType ), 

  iIndex( aIndex ), 

  iButtonId( &aButtonId ),

  iIsUIConstructionCompleted( EFalse ),

  iExiting( EFalse )

    {

    }

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

// CEapTtlsUiDialog::ConstructAndRunLD

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

//

TInt CEapTtlsUiDialog::ConstructAndRunLD( TInt aResourceId )

    {

    CleanupStack::PushL( this );

    iSettingArray = CEapTtlsSettingItemArray::NewL();

    User::LeaveIfError( iConnection->Connect() );

    // Basic data

    iDataConnection = iConnection->GetDataConnection();

    if ( iDataConnection == 0 )

        {

        User::Leave( KErrNoMemory );

        }

    User::LeaveIfError( iDataConnection->Open() );

    User::LeaveIfError( iDataConnection->GetData( &iUiData ) );

    // Cipher suites

    iCipherSuites = iConnection->GetCipherSuiteConnection();

    if ( iCipherSuites == 0 )

        {

        User::Leave( KErrNoMemory );

        }

    User::LeaveIfError( iCipherSuites->Open() );

    User::LeaveIfError( iCipherSuites->GetCipherSuites( &iUiCipherSuites ) );

    iCipherSuitesViewArray = new( ELeave ) CDesCArrayFlat( 

                                                    KSuiteArrayGranularity );

    //EAP types 

    iEapTypes = iConnection->GetEapTypeConnection();

    if ( iEapTypes == 0 )

        {

        User::Leave( KErrNoMemory );

        }

    User::LeaveIfError( iEapTypes->Open() );

    User::LeaveIfError( iEapTypes->GetEapTypes( &iUiEapTypes ) );

    if ( iUiEapTypes->Count() == 0 )

        {

        CreateEapTypeDataBaseL();

        }

    iEapTypeViewArray = new( ELeave ) CDesCArrayFlat( 

                                                    KSettingArrayGranularity );

    FeatureManager::InitializeLibL();

    ConstructL( R_TTLS_MENUBAR );

    // ExecuteLD will PushL( this ), so we have to Pop it...

    CleanupStack::Pop( this ); // this

    return CAknDialog::ExecuteLD( aResourceId );

    }

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

// CEapTtlsUiDialog::OfferKeyEventL

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

//

TKeyResponse CEapTtlsUiDialog::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                     TEventCode aType )

    {

    TKeyResponse result( EKeyWasNotConsumed );

    // gently handle impatient users

	if ( !iIsUIConstructionCompleted )

        {

        return CAknDialog::OfferKeyEventL( aKeyEvent, aType );

        }

    TInt pageId = ActivePageId();

    if ( aType == EEventKey && pageId == KEAPTTLSCIPHERPAGE )

        {

        TInt indexBefore = iCipherSuiteListBox->CurrentItemIndex();

        if ( aKeyEvent.iCode == EKeyEnter )

            {

            if ( ( *iUiCipherSuites )[indexBefore].iIsEnabled )

                {

                OkToExitL( ETtlsUiCmdDisable );

                }

            else

                {

                OkToExitL( ETtlsUiCmdEnable );

                }

            result = EKeyWasConsumed;

            }

        else

            {        

            result = CAknDialog::OfferKeyEventL( aKeyEvent, aType );

            }

        TInt indexAfter = iCipherSuiteListBox->CurrentItemIndex();

        if ( indexBefore != indexAfter )

            {

            CEikButtonGroupContainer& cba = ButtonGroupContainer();

            if( ( *iUiCipherSuites )[ indexAfter ].iIsEnabled )

                {

                cba.SetCommandSetL( R_TTLS_UI_SOFTKEYS_OPTIONS_BACK_DISABLE );

                }

            else

                {

                cba.SetCommandSetL( R_TTLS_UI_SOFTKEYS_OPTIONS_BACK_ENABLE );

                }

            cba.DrawDeferred();

            }

        }

    else if ( aType == EEventKey && pageId == KEAPTTLSEAPPAGE )

        {

        TInt indexBefore = iEapTypesListBox->CurrentItemIndex();

        if ( aKeyEvent.iCode == EKeyEnter )

            {

            if ( ( *iUiEapTypes )[indexBefore].iIsEnabled )

                {

                OkToExitL( ETtlsUiCmdConfigure );

                }

            else

                {

                OkToExitL( ETtlsUiCmdEnable );

                }

            result = EKeyWasConsumed;

            }

        else

            {        

            result = CAknDialog::OfferKeyEventL( aKeyEvent, aType );

            }

        TInt indexAfter = iEapTypesListBox->CurrentItemIndex();

        if ( indexBefore != indexAfter )

            {

            CEikButtonGroupContainer& cba = ButtonGroupContainer();

            if( ( *iUiEapTypes )[indexAfter].iIsEnabled )

                {

                cba.SetCommandSetL( R_TTLS_UI_SOFTKEYS_OPTIONS_BACK_CONFIGURE );

                }

            else

                {

                cba.SetCommandSetL( R_TTLS_UI_SOFTKEYS_OPTIONS_BACK_ENABLE );

                }

            cba.DrawDeferred();

            }        

        }

    else

        {

        result = CAknDialog::OfferKeyEventL( aKeyEvent, aType );

        }

    return result;

    }

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

// CEapTtlsUiDialog::~CEapTtlsUiDialog

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

//

CEapTtlsUiDialog::~CEapTtlsUiDialog()

    {

     if ( iSettingArray )

        {

        iSettingArray->Array()->ResetAndDestroy();

        }

    delete iSettingArray;

    iSettingListBox = NULL;

    iDataConnection->Close();

    delete iDataConnection;

    iCipherSuitesViewArray->Reset();

    delete iCipherSuitesViewArray;    

    iEapTypeViewArray->Reset();

    delete iEapTypeViewArray;

	iCertificates->Close();

	delete iCertificates;

	iCipherSuites->Close();

	delete iCipherSuites;

	iEapTypes->Close();

	delete iEapTypes;

	iConnection->Close();

    delete iPreviousText;

    FeatureManager::UnInitializeLib();

    }

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

// CEapTtlsUiDialog::HandleListBoxEventL

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

//

void CEapTtlsUiDialog::HandleListBoxEventL( CEikListBox* aListBox,

                                            TListBoxEvent aEventType )

    {

    switch ( aEventType )

        {

        case EEventEnterKeyPressed:

        case EEventItemSingleClicked:

            {

            if ( aListBox == iSettingListBox )

                {

                OkToExitL( ETtlsUiCmdChange );                    

                }

            else if ( aListBox == iEapTypesListBox )

                {

                TInt index = iEapTypesListBox->CurrentItemIndex();

                if ( iUiEapTypes->At( index ).iIsEnabled )

                    {

                    ConfigureL(ETrue);   

                    }

                else

                    {

                    OkToExitL( ETtlsUiCmdEnable );

                    }                    

                }

            else if ( aListBox == iCipherSuiteListBox )

                {

                TInt index = iCipherSuiteListBox->CurrentItemIndex();

                if ( iUiCipherSuites->At( index ).iIsEnabled )

                    {

                    OkToExitL( ETtlsUiCmdDisable );

                    }

                else

                    {

                    OkToExitL( ETtlsUiCmdEnable );

                    }

                }

            else

                {

                // Do nothing; we should never end up here

                }

            break;

            }

        case EEventItemActioned:

        case EEventEditingStarted:

        case EEventEditingStopped:

        case EEventPenDownOnItem:

        case EEventItemDraggingActioned:

            {

            break;

            }

        default:

            {

            break;

            };

        };

    }   

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

// CEapTtlsUiDialog::HandleDialogPageEventL

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

//

void CEapTtlsUiDialog::HandleDialogPageEventL( TInt aEventID )

    {

     CAknDialog::HandleDialogPageEventL( aEventID );

         if( iExiting )

             {        

             // Exit requested. 

             TryExitL( EAknCmdExit );

             }   

     }

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

// CEapTtlsUiDialog::ConfigureL

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

//

void CEapTtlsUiDialog::ConfigureL( TBool aQuick )

    {

    RImplInfoPtrArray eapArray;

    eapArray.Reset();

    REComSession::ListImplementationsL( KEapTypeInterfaceUid,

            eapArray );

    TInt itemIndex = iEapTypesListBox->CurrentItemIndex(); 

    TInt eapIndex( 0 );

    for ( TInt i = 0; i < eapArray.Count(); ++i )

        {

        CImplementationInformation* tempInfo = eapArray[i];

        if ( iUiEapTypes->At( itemIndex ).iEapType == 

        tempInfo->DataType() )

            {

            eapIndex = i;

            break;            

            }

        }   

    CEapType* eapType;

    eapType = CEapType::NewL( eapArray[eapIndex]->DataType(), 

            iIndexType, iIndex );

    eapArray.ResetAndDestroy();

    eapType->SetTunnelingType( KEapTtlsId );

    CleanupStack::PushL( eapType );

    TInt buttonId = eapType->InvokeUiL();

    CleanupStack::PopAndDestroy( eapType );

    if ( buttonId == EAknCmdExit || buttonId == EEikCmdExit )

        {

        if (aQuick == EFalse)

            {

            TryExitL( buttonId );

            }

        else

            {

            iExiting = ETrue;

            // Don't exit here. Framework command chain will

            // cause a KERN-EXEC 3 panic. Handle the exit in 

            // HandleDialogPageEventL(). 

            }

        }

    }

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

// CEapTtlsUiDialog::PreLayoutDynInitL

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

//

void CEapTtlsUiDialog::PreLayoutDynInitL()

    {

    // Change title

    ChangeTitleL( ETrue );

    iSettingListBox = static_cast<CAknSettingStyleListBox*>( 

                              ControlOrNull( ETtlsSettingsListbox ) );

    iSettingListBox->SetComponentsToInheritVisibility( ETrue );

    iEapTypesListBox = static_cast<CAknSingleNumberStyleListBox*>(

                              ControlOrNull( ETtlsSettingsEapTypeListbox ) );

    iEapTypesListBox->SetComponentsToInheritVisibility( ETrue );

    iCipherSuiteListBox = static_cast<CAknSingleNumberStyleListBox*>(

                               ControlOrNull( ETtlsSettingsCipherSuiteListbox ) );

    iCipherSuiteListBox->SetComponentsToInheritVisibility( ETrue );

    // Get certificates before building the UI. 

    // Will continue when certificates are received

    iCertificates = iConnection->GetCertificateConnection( this );

    User::LeaveIfError( iCertificates->Open() );

    iCertificates->GetCertificates( &iUiUserCertificates, &iUiCACertificates );

    }

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

// CEapTtlsUiDialog::CompleteReadCertificates

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

//

void CEapTtlsUiDialog::CompleteReadCertificates( const TInt aResult )

    {

    if ( aResult == KErrNone ) // Certifiocates are received from core

        {

        TRAPD( err, CompleteUiConstructionL() );

        if ( err != KErrNone )

            {

            TRAP_IGNORE( TryExitL( KErrCancel ) );        

            }        

        }

    else

        {

        TRAP_IGNORE( TryExitL( KErrCancel ) );

        }

    }

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

// CEapTtlsUiDialog::CompleteUiConstructionL

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

//

void CEapTtlsUiDialog::CompleteUiConstructionL()

    {

    // Initialize setting page 

    iSettingListBox = static_cast<CAknSettingStyleListBox*>( 

                                    ControlOrNull( ETtlsSettingsListbox ) );

    iSettingListBox->SetMopParent( this );

    iSettingListBox->CreateScrollBarFrameL( ETrue );

    iSettingListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                                                CEikScrollBarFrame::EOff,

                                                CEikScrollBarFrame::EAuto );

    iSettingListBox->SetListBoxObserver( this );                                                 

    DrawSettingsListL();

    // Initialize EAP types page

    iEapTypesListBox = static_cast<CAknSingleNumberStyleListBox*>( 

                                ControlOrNull( ETtlsSettingsEapTypeListbox ) );

    iEapTypesListBox->SetMopParent( this );

    iEapTypesListBox->CreateScrollBarFrameL( ETrue );

    iEapTypesListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                                                CEikScrollBarFrame::EOff,

                                                CEikScrollBarFrame::EAuto );

    iEapTypesListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    iEapTypesListBox->SetListBoxObserver( this );     

    // Following deletes internal array created from resources. 

    // To prevent memory leak.

    MDesCArray* internalArray1 = iEapTypesListBox->Model()->ItemTextArray();

    delete internalArray1;