/*

* Copyright (c) 2003-2009 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 class CCertManUIViewDevice

*                Updates Options list depending of the number of

*                marked and unmarked certificates in the listbox.

*                Handles softkey and Option list commands.

*                Handles certificate deletion including confirmation and

*                read-only notes.

*                Shows certificate details view with appropriate

*                warning notes if certificate is corrupted/expired/not valid.

*

*/

// INCLUDE FILES

#include <aknmessagequerydialog.h>

#include <aknnotewrappers.h>            // for warning & information notes

#include <X509CertNameParser.h>

#include <ErrorUI.h>

#include <x509cert.h>

#include <pkixcertchain.h>              //for validation

#include <certmanui.rsg>

#include "CertmanuiCertificateHelper.h"

#include "CertmanuiKeeper.h"

#include "CertmanuiviewDevice.h"

#include "CertmanuicontainerDevice.h"

#include "Certmanui.hrh"

#include "Certmanuitrustids.h"

#include "CertmanuiSyncWrapper.h"

#include "CertmanuiCommon.h"

#include "CertManUILogger.h"

#include    <hlplch.h>                  // For HlpLauncher

#include    <featmgr.h>                 // For FeatureManager

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

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

// CCertManUIViewDevice::CCertManUIViewDevice(CCertManUIKeeper& aKeeper)

// : iKeeper(aKeeper), iCrMgr(iKeeper.CertManager())

// Constructor

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

//

CCertManUIViewDevice::CCertManUIViewDevice( CCertManUIKeeper& aKeeper )

    : iKeeper( aKeeper )

    {

    CERTMANUILOGGER_WRITE_TIMESTAMP(

        "CCertManUIViewDevice::CCertManUIViewDevice" );

    }

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

// CCertManUIViewDevice::~CCertManUIViewDevice()

// Destructor

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

//

CCertManUIViewDevice::~CCertManUIViewDevice()

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewDevice::~CCertManUIViewDevice" );

    if ( iContainerDevice )

        {

        AppUi()->RemoveFromViewStack( *this, iContainerDevice );

        delete iContainerDevice;

        }

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewDevice::~CCertManUIViewDevice" );

    }

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

// CCertManUIViewDevice* CCertManUIViewDevice::NewL(

//      const TRect& /*aRect*/, CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewDevice* CCertManUIViewDevice::NewL(

    const TRect& /*aRect*/, CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewDevice* self =

        new ( ELeave ) CCertManUIViewDevice( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCertManUIViewDevice* CCertManUIViewDevice::NewLC(

//  const TRect& /*aRect*/, CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewDevice* CCertManUIViewDevice::NewLC(

    const TRect& /*aRect*/, CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewDevice* self =

        new ( ELeave ) CCertManUIViewDevice( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCertManUIViewDevice::ConstructL()

// EPOC two-phased constructor

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

//

void CCertManUIViewDevice::ConstructL()

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewDevice::ConstructL" );

    BaseConstructL( R_CERTMANUI_VIEW_MAIN_DEVICE );

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewDevice::ConstructL" );

    }

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

// CCertManUIViewDevice::DynInitMenuPaneL(

//      TInt aResourceId,CEikMenuPane* aMenuPane)

// Updates Options list with correct items depending on

// whether the listbox is empty or if it has any marked items

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

//

void CCertManUIViewDevice::DynInitMenuPaneL(

    TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewDevice::DynInitMenuPaneL" );

    if (( iKeeper.iWrapper->IsActive()) ||

        ( iContainerDevice->iListBox->CurrentItemIndex() >= iKeeper.iDeviceLabelEntries.Count()))

        {

        return;

        }

    const CListBoxView::CSelectionIndexArray* selections =

            iContainerDevice->iListBox->SelectionIndexes();

    const TInt markedCount = selections->Count();

    const TInt currentItemIndex = iContainerDevice->iListBox->CurrentItemIndex();

    switch ( aResourceId )

        {

        case R_CERTMANUI_VIEW_MENU_DEVICE:

            {

            if( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                aMenuPane->DeleteMenuItem( EAknCmdHelp );

                }

            // the certificate list is empty, all except Exit are dimmed

            if ( currentItemIndex == -1 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdMoveToPersonal, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdMarkUnmark, ETrue );

                }

            else

                {

                if ( markedCount == 1 )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                    }

                if ( markedCount > 1 )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                    aMenuPane->SetItemDimmed( ECertManUICmdMoveToPersonal, ETrue );

                    }

                if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                        iContainerDevice->iListBox, KCertTypeDevice ) )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                    aMenuPane->SetItemDimmed( ECertManUICmdMoveToPersonal, ETrue );

                    }

                }

            break;

            }

        case R_CERTMANUI_MENUPANE_OPTIONS_MARKED:

            {

            if ( markedCount > 1 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdMoveToPersonal, ETrue );

                }

            if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                    iContainerDevice->iListBox, KCertTypeDevice ) )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                }

            // not available for device certificates

            aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

            }

            // FALLTHROUGH

        case R_CERTMANUI_MENU_PANE_MARK_UNMARK:

            {

            TInt index = 0;

            TKeyArrayFix key( 0, ECmpTInt );

            if ( selections->Find( currentItemIndex, key, index ) )

                {   // focus is on unmarked item

                aMenuPane->SetItemDimmed( ECertManUICmdUnmark, ETrue );

                }

            else

                {   // focus is on marked item

                aMenuPane->SetItemDimmed( ECertManUICmdMark, ETrue );

                }

            // if all items are marked, dim "mark all" option

            if ( markedCount == iContainerDevice->iListBox->Model()->NumberOfItems() )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdMarkAll, ETrue );

                }

            // if no items are marked, dim "unmark all" option

            if ( markedCount == 0 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdUnmarkAll, ETrue );

                }

            break;

            }

        default:

            break;

        }

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewDevice::DynInitMenuPaneL" );

    }

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

// CCertManUIViewDevice::Id() const

// Returns Authority view id

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

//

TUid CCertManUIViewDevice::Id() const

    {

    return KCertManUIViewDeviceId;

    }

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

// CCertManUIViewDevice::HandleCommandL(TInt aCommand)

// Handles Softkey and Options list commands

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

//

void CCertManUIViewDevice::HandleCommandL( TInt aCommand )

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewDevice::HandleCommandL" );

    if (( iKeeper.iWrapper->IsActive() ) ||

        ( iContainerDevice->iListBox->CurrentItemIndex() >= iKeeper.iDeviceLabelEntries.Count() ))

        {

        return;

        }

    switch ( aCommand )

        {

        case EAknSoftkeyBack:

            {

            // Activate main view

            AppUi()->ActivateLocalViewL( KCertManUIViewMainId );

            break;

            }

        // put the view specific menu commands here

        case EAknCmdExit:

            {

            ((CAknViewAppUi*)iAvkonAppUi)->HandleCommandL( EAknCmdExit );

            break;

            }

        case ECertManUICmdAppViewDtls:

            {

            iKeeper.iCertificateHelper->MessageQueryViewDetailsL(

                iContainerDevice->iListBox->CurrentItemIndex(),

                KCertTypeDevice, iEikonEnv );

            break;

            }

        case ECertManUICmdAppDelete:

            {

            if ( iKeeper.iCertificateHelper->ConfirmationQueryDeleteCertL( KCertTypeDevice,

                                                    iContainerDevice->iListBox) )

                {

                // goes here if at least one certificate is deleted

                iCurrentPosition = iContainerDevice->iListBox->CurrentItemIndex();

                iTopItem = iContainerDevice->iListBox->TopItemIndex();

                iContainerDevice->DrawListBoxL(iCurrentPosition, iTopItem );

                TRAPD( error, iKeeper.RefreshDeviceCertEntriesL() );

                if ( error != KErrNone )

                    {

                    if ( error == KErrCorrupt )

                        {

                        iKeeper.ShowErrorNoteL( error );

                        User::Exit( KErrNone );

                        }

                    else

                        {

                        // have to call straight away the Exit

                        // showing any error notes would corrupt the display

                        User::Exit( error );

                        }

                    }

                UpdateMenuBar();

                }

            break;

            }

       case ECertManUICmdMoveToPersonal:

            {

            HBufC* prompt = StringLoader::LoadLC(

                        R_QTN_CM_CONF_MOVE_TO_PERSONAL );

            TInt selection = iKeeper.iCertificateHelper->DisplayConfirmationLD(prompt);

            if ( selection )

                {

                TInt focusPosition = 0;

                const CArrayFix<TInt>* array = iContainerDevice->iListBox->SelectionIndexes();

                if ( array->Count() == 1 )

                    {

                    // item is marked

                    focusPosition = array->At( 0 );

                    }

                else

                    {

                    // There is no marked item. Select higlighted item 

                    focusPosition = iContainerDevice->iListBox->CurrentItemIndex();

                    }

                CCTCertInfo* entry = iKeeper.iDeviceLabelEntries[ focusPosition ]->iDeviceEntry;

                // Move key first

                TCTKeyAttributeFilter keyFilter;

                keyFilter.iKeyId = entry->SubjectKeyId();

                keyFilter.iPolicyFilter =  TCTKeyAttributeFilter::EAllKeys;

                TRAPD( error, iKeeper.iCertificateHelper->MoveKeyL( keyFilter,

                                KCMDeviceKeyStoreTokenUid, KCMFileKeyStoreTokenUid ));

                if ( error == KErrNone )

                    {

                    iKeeper.iCertificateHelper->MoveCertL(

                                                      *entry,

                                                      focusPosition,

                                                      iContainerDevice->iListBox,

                                                      KCMDeviceCertStoreTokenUid,

                                                      KCMFileCertStoreTokenUid );

                    TRAP( error, iKeeper.RefreshDeviceCertEntriesL() );

                    if ( error != KErrNone )

                        {

                        if ( error == KErrCorrupt )

                            {

                            iKeeper.ShowErrorNoteL( error );

                            User::Exit( KErrNone );

                            }

                        else

                            {

                            // have to call straight away the Exit

                            // showing any error notes would corrupt the display

                            User::Exit( error );

                            }

                        }

                    MDesCArray* itemList = iContainerDevice->iListBox->Model()->ItemTextArray();

                    CDesCArray* itemArray = ( CDesCArray* )itemList;

                    if (( itemArray != NULL ) && ( itemArray->Count() == 0 ))

                        {

                        iCurrentPosition = 0;

                        iTopItem = 0;

                        iContainerDevice->UpdateListBoxL( iCurrentPosition, iTopItem );

                        }

                     else

                        {

                        iCurrentPosition = iContainerDevice->iListBox->CurrentItemIndex();

                        iTopItem = iContainerDevice->iListBox->TopItemIndex();

                        }

                    iContainerDevice->DrawListBoxL(iCurrentPosition, iTopItem );

                    UpdateMenuBar();

                    }

                }

            break;

            }

        case ECertManUICmdMark:

        case ECertManUICmdUnmark:

        case ECertManUICmdMarkAll:

        case ECertManUICmdUnmarkAll:

            {

            // Gets pointer of current listbox.

            CEikListBox* listbox = iContainerDevice->iListBox;

            if ( listbox )

                {

                AknSelectionService::HandleMarkableListProcessCommandL(

                    aCommand, listbox );

                iKeeper.iCertificateHelper->

                                    HandleMarkableListCommandL(

                                                              aCommand,

                                                              iContainerDevice->iListBox

                                                              );

                UpdateMenuBar();

                }

            break;

            }

        case EAknCmdHelp:

            {

            if( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                HlpLauncher::LaunchHelpApplicationL(

                   iEikonEnv->WsSession(), AppUi()->AppHelpContextL() );

                }

            break;

            }

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewDevice::HandleCommandL" );

    }

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

// CCertManUIViewDevice::HandleClientRectChange()

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

//

void CCertManUIViewDevice::HandleClientRectChange()

    {

    if ( iContainerDevice )

        {

        iContainerDevice->SetRect( ClientRect() );

        }

    }

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

// CCertManUIViewDevice::DoActivateL(const TVwsViewId& /*aPrevViewId*/,

//      TUid /*aCustomMessageId*/, const TDesC8& /*aCustomMessage*/)

// Updates the view when opening it

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

//

void CCertManUIViewDevice::DoActivateL(

    const TVwsViewId& aPrevViewId,

    TUid /*aCustomMessageId*/, const TDesC8& /*aCustomMessage*/)

    {

     CERTMANUILOGGER_ENTERFN( " CCertManUIViewDevice::DoActivateL" );

     iKeeper.StartWaitDialogL( ECertmanUiWaitDialog );

     CleanupCloseWaitDialogPushL( iKeeper );

     TRAPD ( error, iKeeper.RefreshDeviceCertEntriesL() );

     if ( error != KErrNone )

         {

         if ( error == KErrCorrupt )

             {

             iKeeper.ShowErrorNoteL( error );

             User::Exit( KErrNone );

             }

         else

             {

             // have to call straight away the Exit

             // showing any error notes would corrupt the display

             User::Exit( error );

             }

         }

    // If this view is being activated from main view,

    // current position is 0. The declaration of KCertManUIViewMainId is

    // located in certmanuiviewid.h which is not public header --> constant

    // is being used.

    if( aPrevViewId.iViewUid == KCertManUIViewMainId )

        {

        iCurrentPosition = 0;

        }

    if ( iContainerDevice )

        {

        ((CAknViewAppUi*)iAvkonAppUi)->RemoveFromViewStack(

            *this, iContainerDevice );

        delete iContainerDevice;

        iContainerDevice = NULL;

        }

    iContainerDevice = new (ELeave) CCertManUIContainerDevice(

        *this, iKeeper );

    iContainerDevice->SetMopParent( this );

    iContainerDevice->ConstructL(

        ClientRect(), iCurrentPosition, iTopItem );

    if ( !iKeeper.iCertsDatOK )

        {

        iCurrentPosition = 0;

        iTopItem = 0;

        }

    iKeeper.ActivateTitleL( KViewTitleCertManUIDevice );

    iContainerDevice->DrawListBoxL( iCurrentPosition, iTopItem );

    ((CAknViewAppUi*)iAvkonAppUi)->AddToStackL( *this, iContainerDevice );

    UpdateMenuBar();

    CleanupStack::PopAndDestroy();    // closes wait dialog

    iKeeper.iStartup = EFalse;

     CERTMANUILOGGER_LEAVEFN( " CCertManUIViewDevice::DoActivateL" );

    }

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

// CCertManUIViewDevice::DoDeactivate()

// Saves focus position when closing view

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

//