/*

* Copyright (c) 2005-2007 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:  Phonebook 2 command handler.

*

*/

// INCLUDE FILES

#include "CPbk2CommandHandler.h"

// Phonebook 2

#include "CPbk2CommandFactory.h"

#include "CPbk2CommandStore.h"

#include "CPbk2AiwInterestArray.h"

#include <MPbk2ViewExplorer.h>

#include <CPbk2AppViewBase.h>

#include <CPbk2AppUiBase.h>

#include <CPbk2UIExtensionManager.h>

#include <MPbk2Command.h>

#include <Pbk2Commands.rsg>

#include <Pbk2UIControls.rsg>

#include <CPbk2ViewState.h>

#include <CPbk2PhonebookInfoDlg.h>

#include <TPbk2StoreContactAnalyzer.h>

#include <MPbk2ContactNameFormatter.h>

#include <CPbk2StoreProperty.h>

#include <CPbk2StorePropertyArray.h>

#include <CPbk2ContactRelocator.h>

#include <MPbk2ContactLinkIterator.h>

#include <CPbk2PresentationContact.h>

#include <CPbk2PresentationContactFieldCollection.h>

#include <CPbk2FieldPropertyArray.h>

#include <cpbk2commandactivator.h>

#include <CPbk2ApplicationServices.h>

#include <MPbk2AppUi.h>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactAttributeManager.h>

#include <MVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <CVPbkSpeedDialAttribute.h>

#include <MVPbkStoreContact.h>

#include <VPbkContactStoreUris.h>

// System includes

#include <avkon.hrh>

#include <eikmenup.h>

#include <featmgr.h>

#include <hlplch.h>

#include <akntoolbar.h>

#include <eikmenub.h>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPreCond_CmdOpenMeViewsL = 1,

    EPanicPreCond_CmdOpenSettingsViewL,

    EPanicPreCond_CmdOpenPreviousViewL,

    EPanicPreCond_CmdOpenHelpL,

    EPanicLogic_FocusedFieldMatchesFieldTypeL,

    EPanicLogic_FocusedContactHasFieldTypeL

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2CommandHandler");

    User::Panic(KPanicText, aReason);

    }

#endif //_DEBUG

/**

 * Checks if focused field is of given field type.

 *

 * @param aUiControl        UI control.

 * @param aSelectorResId    Selector resource id.

 * @param aContactManager   Virtual Phonebook contact manager.

 * @return  ETrue if field type matches with given types.

 */

TBool FocusedFieldMatchesFieldTypeL(

        MPbk2ContactUiControl& aUiControl,

        TInt aSelectorResId,

        CVPbkContactManager& aContactManager )

    {

    const MVPbkStoreContact* contact = aUiControl.FocusedStoreContact();

    __ASSERT_DEBUG(contact, Panic

            ( EPanicLogic_FocusedFieldMatchesFieldTypeL ) );

    TPbk2StoreContactAnalyzer analyzer( aContactManager, NULL );

    const MVPbkBaseContactField* field = aUiControl.FocusedField();

    return field &&

        analyzer.IsFieldTypeIncludedL( *field, aSelectorResId );

    }

/**

 * Checks if the focused contact have a given field type.

 *

 * @param aUiControl        UI control

 * @param aSelectorResId    Selector resource id.

 * @param aContactManager   Virtual Phonebook contact manager.

 * @return  Index of the field having the type, KErrNotFound if

 *          the contact does not have the field type.

 */

 TInt FocusedContactHasFieldTypeL(

        MPbk2ContactUiControl& aUiControl,

        TInt aSelectorResId,

        CVPbkContactManager& aContactManager )

    {

    TInt ret = KErrNotFound;

    const MVPbkStoreContact* contact = aUiControl.FocusedStoreContact();

    __ASSERT_DEBUG( contact,

        Panic( EPanicLogic_FocusedContactHasFieldTypeL ) );

    TPbk2StoreContactAnalyzer analyzer( aContactManager, contact );

    ret = analyzer.HasFieldL( aSelectorResId );

    return ret;

    }

/**

 * Checks if command is 'exit' command.

 *

 * @param aCommandId    The command to check.

 * @return  ETrue if command is an exit command, EFalse otherwise.

 */

TBool IsExitCommand( TInt aCommandId )

    {

    TBool ret = EFalse;

    if ( EEikCmdExit == aCommandId || EAknSoftkeyExit == aCommandId ||

         EAknCmdExit == aCommandId || EPbk2CmdExit == aCommandId )

        {

        ret = ETrue;

        }

    return ret;

    }

} /// namespace

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

// CPbk2CommandHandler::CPbk2CommandHandler

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

//

inline CPbk2CommandHandler::CPbk2CommandHandler()

    {

    }

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

// CPbk2CommandHandler::~CPbk2CommandHandler

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

//

CPbk2CommandHandler::~CPbk2CommandHandler()

    {

    delete iAiwInterestArray;

    delete iCommandStore;

    delete iCommandFactory;

    delete iContactRelocator;

    Release(iExtensionManager);

    Release(iAppServices);

    FeatureManager::UnInitializeLib();

    }

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

// CPbk2CommandHandler::NewL

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

//

EXPORT_C CPbk2CommandHandler* CPbk2CommandHandler::NewL()

    {

    CPbk2CommandHandler* self = new(ELeave) CPbk2CommandHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CPbk2CommandHandler::ConstructL

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

//

inline void CPbk2CommandHandler::ConstructL()

    {

    iCommandFactory = CPbk2CommandFactory::NewL();

    iCommandStore = CPbk2CommandStore::NewL();

    iAiwInterestArray = CPbk2AiwInterestArray::NewL();

    iExtensionManager = CPbk2UIExtensionManager::InstanceL();

    iContactRelocator = CPbk2ContactRelocator::NewL();

    iAppServices = CPbk2ApplicationServices::InstanceL();

    // Initialize feature manager

    FeatureManager::InitializeLibL();

    }

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

// CPbk2CommandHandler::HandleCommandL

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

//

TBool CPbk2CommandHandler::HandleCommandL

        ( const TInt aCommandId, MPbk2ContactUiControl& aControl,

          const CPbk2AppViewBase* aAppView )

    {

    TBool ret = ETrue;

    // Exit commands are forwarded right away to appui

    // Otherwise there is possibility that

    // 'exit' command is not handled in low memory situations

    if ( IsExitCommand( aCommandId ) )

        {

        ret = EFalse;

        }

    // Offer the command to AIW unless it is exit command

    if ( ret && !iAiwInterestArray->HandleCommandL

            ( aCommandId, aControl, KNullHandle ) )

        {

        // Try generic command, this can also be a command from an extension

        ret = CmdGenericCommandL( TPbk2CommandId( aCommandId ), aControl );

        if ( !ret )

            {

            ret = ETrue;

            switch ( aCommandId )

                {

                case EAknSoftkeyBack:               // FALLTHROUGH

                case EPbk2CmdOpenPreviousView:

                    {

                    CmdOpenPreviousViewL( aControl, aAppView );

                    break;

                    }

                case EPbk2CmdSettings:

                    {

                    CmdOpenSettingsViewL( aControl, aAppView,

                        Phonebook2::KPbk2SettingsViewUid );

                    break;

                    }

                case EAknCmdHelp:

                    {

                    CmdOpenHelpL( aControl, aAppView );

                    break;

                    }

                default:

                    {

                    ret = EFalse;

                    break;

                    }

                }

            }

        }

    return ret;

    }

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

// CPbk2CommandHandler::DynInitMenuPaneL

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

//

void CPbk2CommandHandler::DynInitMenuPaneL(

        TInt aResourceId,

        CEikMenuPane* aMenuPane,

        CPbk2AppViewBase& aViewBase,

        MPbk2ContactUiControl& aControl )

    {

    // First, delegate to AIW interests.

    // If the menu initialization is handled there,

    // there's no need to continue here

    if ( !iAiwInterestArray->DynInitMenuPaneL

            ( aResourceId, *aMenuPane, aControl ) )

        {

        // Then call extensions

        iExtensionManager->DynInitMenuPaneL( aResourceId, aMenuPane,

            aViewBase, aControl );

        // First perform standard menu filtering

        PerformStandardMenuFilteringL( aResourceId, aMenuPane, aControl );

        // Then perform field type based filtering

        PerformFieldTypeBasedFilteringL( aResourceId, aMenuPane, aControl );

        // Finally perform store specific filtering

        PerformStoreSpecificFilteringL( aResourceId, aMenuPane, aControl );

        }

    }

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

// CPbk2CommandHandler::RegisterAiwInterestL

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

//

void CPbk2CommandHandler::RegisterAiwInterestL(

        const TInt aInterestId,

        const TInt aMenuResourceId,

        const TInt aInterestResourceId,

        const TBool aAttachBaseService)

    {

    iAiwInterestArray->QueueInterestL(aInterestId,

        aMenuResourceId, aInterestResourceId, aAttachBaseService);

    }

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

// CPbk2CommandHandler::ServiceCmdByMenuCmd

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

//

TInt CPbk2CommandHandler::ServiceCmdByMenuCmd(

        TInt aMenuCmdId ) const

    {

    return iAiwInterestArray->ServiceCmdByMenuCmd( aMenuCmdId );

    }

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

// CPbk2CommandHandler::AddAndExecuteCommandL

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

//

void CPbk2CommandHandler::AddAndExecuteCommandL(

        MPbk2Command* aCommand)

    {

    iCommandStore->AddAndExecuteCommandL(aCommand);

    }

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

// CPbk2CommandHandler::AddMenuCommandObserver

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

//

void CPbk2CommandHandler::AddMenuCommandObserver(

        MPbk2MenuCommandObserver& aObserver)

    {

    iCommandStore->AddMenuCommandObserver(aObserver);

    }

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

// CPbk2CommandHandler::RemoveMenuCommandObserver

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

//

void CPbk2CommandHandler::RemoveMenuCommandObserver(

        MPbk2MenuCommandObserver& aObserver)

    {

    iCommandStore->RemoveMenuCommandObserver(aObserver);

    }

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

// CPbk2CommandHandler::DynInitToolbarL

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

//

void CPbk2CommandHandler::DynInitToolbarL

        ( TInt aResourceId, CAknToolbar* aToolbar,

          const CPbk2AppViewBase& /*aAppView*/,

          MPbk2ContactUiControl& aControl )

    {

    switch ( aResourceId )

        {

        case R_PBK2_NAMESLIST_TOOLBAR:

            {

            if ( aControl.FocusedContactIndex() == KErrNotFound )

                {

                // If there is not focused contact (empty list or otherwise no

                // focus) then disable calling and message writing

                aToolbar->SetItemDimmed( EPbk2CmdCall, ETrue, ETrue );

                aToolbar->SetItemDimmed( EPbk2CmdWriteNoQuery, ETrue, ETrue );

                }

            else if ( aControl.ContactsMarked() )

                {

                // Disable calling to many contacts

                aToolbar->SetItemDimmed( EPbk2CmdCall, ETrue, ETrue );

                }

            break;

            }

        }

    }

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

// CPbk2CommandHandler::OfferToolbarEventL

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

//

void CPbk2CommandHandler::OfferToolbarEventL

        ( TInt aCommand, MPbk2ContactUiControl& aControl,

          const CPbk2AppViewBase* aAppView )

    {

    if ( aAppView )

        {

    HandleCommandL( aCommand, aControl, aAppView );

        }

    }

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

// CPbk2CommandHandler::CmdOpenSettingsViewL

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

//

void CPbk2CommandHandler::CmdOpenSettingsViewL

        ( MPbk2ContactUiControl& aControl,

          const CPbk2AppViewBase* aAppView, TUid aViewId )

    {

    if (aAppView)

        {

        // Phonebook 2 view explorer for view switching

        MPbk2ViewExplorer* viewExplorer = Phonebook2::Pbk2AppUi()->Pbk2ViewExplorer();

        __ASSERT_DEBUG( viewExplorer,

            Panic( EPanicPreCond_CmdOpenSettingsViewL ) );

        CPbk2ViewState* state = aAppView->ViewStateLC();

        viewExplorer->ActivatePhonebook2ViewL

            ( aViewId, state );

        CleanupStack::PopAndDestroy( state );

        aControl.UpdateAfterCommandExecution();

        }

    }

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

// CPbk2CommandHandler::CmdOpenPreviousViewL

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

//

void CPbk2CommandHandler::CmdOpenPreviousViewL

        ( MPbk2ContactUiControl& /*aControl*/,

          const CPbk2AppViewBase* aAppView )

    {

    if (aAppView)

        {

        // Phonebook 2 view explorer for view switching

        MPbk2ViewExplorer* viewExplorer = Phonebook2::Pbk2AppUi()->Pbk2ViewExplorer();

        CPbk2ViewState* state = aAppView->ViewStateLC();

        viewExplorer->ActivatePreviousViewL( state );

        CleanupStack::PopAndDestroy( state );

        }

    }

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

// CPbk2CommandHandler::CmdOpenHelpL

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

//

void CPbk2CommandHandler::CmdOpenHelpL

        ( MPbk2ContactUiControl& aControl,

          const CPbk2AppViewBase* aAppView )

    {

    if ( aAppView )

        {

    TCoeHelpContext helpContext;

    if ( iExtensionManager->GetHelpContextL

            ( helpContext, *aAppView, aControl) )

        {

        CArrayFix<TCoeHelpContext>* helpContextArray =

                new (ELeave) CArrayFixFlat<TCoeHelpContext>( 1 );

        CleanupStack::PushL( helpContextArray );

        helpContextArray->AppendL( helpContext );

        // HlpLauncher destroys the help context array

        CleanupStack::Pop( helpContextArray );

        HlpLauncher::LaunchHelpApplicationL

            ( CCoeEnv::Static()->WsSession(), helpContextArray );

        }

    else

        {

        HlpLauncher::LaunchHelpApplicationL

            ( CCoeEnv::Static()->WsSession(),

              CEikonEnv::Static()->EikAppUi()->AppHelpContextL() );

            }

        }

    }

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

// CPbk2CommandHandler::CmdGenericCommandL

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

//

TBool CPbk2CommandHandler::CmdGenericCommandL(

        TPbk2CommandId aCommandId,

        MPbk2ContactUiControl& aControl)

    {

    // Create the command object

    TBool result = EFalse;

    MPbk2Command* cmd = iCommandFactory->CreateCommandForIdL(

            aCommandId, aControl);

    if (cmd)

        {

        // If command factory was able to create the command,

        // add it to the command store and execute it

        iCommandStore->AddAndExecuteCommandL(cmd);

        result = ETrue;

        }

    return result;

    }

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

// CPbk2CommandHandler::PerformStandardMenuFilteringL

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

//

inline void CPbk2CommandHandler::PerformStandardMenuFilteringL(

        TInt aResourceId,

        CEikMenuPane* aMenuPane,

        MPbk2ContactUiControl& aControl )

    {

    switch (aResourceId)

        {

        case R_PHONEBOOK2_NAMESLIST_DELETE_MENU:

            {

            if ( aControl.NumberOfContacts() == 0 )

                {

                aMenuPane->SetItemDimmed( EPbk2CmdDeleteMe, ETrue );

                }

            if ( aControl.ContactsMarked() )

                {

                aMenuPane->SetItemSpecific( EPbk2CmdDeleteMe, EFalse );

                }

            break;

            }

        case R_PHONEBOOK2_NAMELIST_CALL_CONTACT_MENU:

            {

            // Weed out commands not meant to be used with marked items

            if ( aControl.ContactsMarked() )

                {

                aMenuPane->SetItemDimmed( EPbk2CmdCall, ETrue );

                }

            break;