/*

* 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 call AIW interest item.

*

*/

// INCLUDE FILES

#include "CPbk2AiwInterestItemCall.h"

// Phonebook 2

#include "CPbk2CallCmd.h"

#include "CPbk2PrependCmd.h"

#include "CPbk2PocCmd.h"

#include <MPbk2Command.h>

#include "MPbk2CommandFactory.h"

#include "CPbk2CallTypeSelector.h"

#include <MPbk2ContactUiControl.h>

#include <Pbk2UIControls.rsg>

#include <Pbk2Commands.rsg>

#include <CPbk2FieldPropertyArray.h>

#include <CPbk2AddressSelect.h>

#include <TPbk2AddressSelectParams.h>

#include <TPbk2StoreContactAnalyzer.h>

#include <CPbk2PresentationContact.h>

#include <CPbk2PresentationContactFieldCollection.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2AppUi.h>

#include <CPbk2ApplicationServices.h>

#include "cpbk2storestatechecker.h"

#include <MPbk2AppUi.h>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <VPbkFieldTypeSelectorFactory.h>

#include <MVPbkContactOperationBase.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkxSPContacts.h>

#include <CVPbkFieldTypeSelector.h>

// System includes

#include <AiwServiceHandler.h>

#include <eikmenup.h>

#include <eikenv.h>

#include <featmgr.h>

#include <spsettingsvoiputils.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

/**

 * Standard error handling.

 *

 * @param aError    Error code.

 */

void HandleError( const TInt aError )

    {

    if (aError != KErrNone)

        {

        // Get UIKON environment

        CEikonEnv* eikEnv = CEikonEnv::Static();

        if (eikEnv)

            {

            // Display standard error message

            eikEnv->HandleError(aError);

            }

        }

    }

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicLogic_DynInitMenuPaneL = 1,

    EPanicPreCond_ExecuteCommandL,

    EPanicLogic_UnknownState

    };

void Panic(TPanicCode aReason)

    {

    _LIT( KPanicText, "CPbk2AiwInterestItemCall" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

/**

 * Copies a link array to another.

 *

 * @param aSourceLinkArray    Link array which is copied

 * @param aTargetLinkArray    Links are copied to this

 */

void CopyContactLinksL( const MVPbkContactLinkArray& aSourceLinkArray,

        CVPbkContactLinkArray& aTargetLinkArray )

    {

    const TInt count = aSourceLinkArray.Count();

    for ( TInt i(0); i < count; ++i )

        {

        const MVPbkContactLink& contactLink = aSourceLinkArray.At(i);

        aTargetLinkArray.AppendL( contactLink.CloneLC() );

        CleanupStack::Pop(); // link

        }

    }

} /// namespace

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

// CPbk2AiwInterestItemCall::CPbk2AiwInterestItemCall

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

//

inline CPbk2AiwInterestItemCall::CPbk2AiwInterestItemCall

        ( TInt aInterestId, CAiwServiceHandler& aServiceHandler ) :

            CPbk2AiwInterestItemBase( aInterestId, aServiceHandler )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::CPbk2AiwInterestItemCall") );

    CActiveScheduler::Add( this );

    }

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

// CPbk2AiwInterestItemCall::~CPbk2AiwInterestItemCall

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

//

CPbk2AiwInterestItemCall::~CPbk2AiwInterestItemCall()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::~CPbk2AiwInterestItemCall") );

    Cancel();

    FeatureManager::UnInitializeLib();

    delete iStoreStateChecker;

    delete iFocusedField;

    delete iContactLink;

    delete iStoreContact;

    delete iSelector;

    delete iRetriever;

    delete ixSPManager;

    delete ixSPContactLinksArray;

    ixSPStoreContactsArray.ResetAndDestroy();

    Release( iAppServices );    

    }

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

// CPbk2AiwInterestItemCall::ConstructL

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

//

inline void CPbk2AiwInterestItemCall::ConstructL()

    {

    iAppServices = CPbk2ApplicationServices::InstanceL();

    iFieldPropertyArray = &iAppServices->FieldProperties();

    iSelector = CPbk2CallTypeSelector::NewL( iAppServices->ContactManager() );

    iAppUi = Phonebook2::Pbk2AppUi();

    FeatureManager::InitializeLibL();

    }

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

// CPbk2AiwInterestItemCall::NewL

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

//

CPbk2AiwInterestItemCall* CPbk2AiwInterestItemCall::NewL

        ( TInt aInterestId, CAiwServiceHandler& aServiceHandler )

    {

    CPbk2AiwInterestItemCall* self = new ( ELeave ) CPbk2AiwInterestItemCall

        ( aInterestId, aServiceHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2AiwInterestItemCall::DynInitMenuPaneL

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

//

TBool CPbk2AiwInterestItemCall::DynInitMenuPaneL

        ( const TInt aResourceId, CEikMenuPane& aMenuPane,

        const MPbk2ContactUiControl& aControl )

    {

    TBool ret = EFalse;

    // Normal menu

    if ( aResourceId == R_PHONEBOOK2_CALL_MENU || 

        aResourceId == R_PHONEBOOK2_STYLUS_CALL_MENU )

        {

        ret = ETrue;

        FilterCallMenuL( aResourceId, aMenuPane, aControl );

        }

    // Context menu

    else if (aResourceId == R_PHONEBOOK2_CALL_CONTEXT_MENU)

        {

        ret = ETrue;

        FilterContextMenuL( aResourceId, aMenuPane, aControl );

        }

    return ret;

    }

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

// CPbk2AiwInterestItemCall::HandleCommandL

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

//

TBool CPbk2AiwInterestItemCall::HandleCommandL

        ( const TInt aMenuCommandId, MPbk2ContactUiControl& aControl,

          TInt aServiceCommandId )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::HandleCommandL(0x%x)"), aMenuCommandId );

    // Reset previous request if active

    Cancel();

    TBool ret = EFalse;

    // Only handle this command if service command is call,

    // note that this section is accessed also when the send key

    // is pressed and the initiated command object can then be POC

    // call also

    if ( aServiceCommandId == KAiwCmdCall )

        {

        ret = ETrue;

        iMenuCommandId = aMenuCommandId;

        iControl = &aControl;

        // Retrieve store contact if needed

        MVPbkStoreContact* storeContact = const_cast<MVPbkStoreContact*>

            ( aControl.FocusedStoreContact() );

        if ( !storeContact )

            {

            // No need to check store state, store always available

            // if cmd is invoked from nameslist

            IssueNextAction( ERetrieveStoreContact );

            }

        else

            {

            // Check store availability, callback invokes

            // call if store is available

            CPbk2StoreStateChecker* temp =  CPbk2StoreStateChecker::NewL

                (  storeContact->ParentStore(), *this );

            delete iStoreStateChecker;

            iStoreStateChecker = temp;

            }

        }

    return ret;

    }

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

// CPbk2AiwInterestItemCall::VPbkSingleContactOperationComplete

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

//

void CPbk2AiwInterestItemCall::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& aOperation,

          MVPbkStoreContact* aContact )

    {

    if ( &aOperation == iRetriever )

        {

        if ( iState == ERetrieveStoreContact )

            {

            delete iStoreContact;

            iStoreContact = aContact;

            // Start retieving xSP contacts

            TRAPD( err, FetchxSPLinksL() );

            if (err != KErrNone)

                {

                IssueNextAction( EExecuteCall );

                }

            }

        // Retrieve one xSP contact at a time

		// No batch implementation for retrieve contacts

        if ( iState == ERetrieveXSPContact )

            {

            // xSP contact retrieval complete. Store it.

            TInt err = ixSPStoreContactsArray.Append( aContact );

            // Start retrieving next xSP contact links if any left

            if ( ixSPContactLinksArray->Count() > 0 && err == KErrNone )

                {

                IssueNextAction( ERetrieveXSPContact );

                }

            // If none, or if error execute the call.

            else

                {

                IssueNextAction( EExecuteCall );

                }            

            }

        }

    }

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

// CPbk2AiwInterestItemCall::VPbkSingleContactOperationFailed

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

//

void CPbk2AiwInterestItemCall::VPbkSingleContactOperationFailed

    ( MVPbkContactOperationBase& aOperation, TInt aError )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::VPbkSingleContactOperationFailed(%d)"), aError );

    if ( &aOperation == iRetriever )

        {

        HandleError( aError );

        }

    }

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

// CPbk2AiwInterestItemCall::StoreState

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

//

void CPbk2AiwInterestItemCall::StoreState

        ( MPbk2StoreStateCheckerObserver::TState aState )

    {

    if ( aState == MPbk2StoreStateCheckerObserver::EStoreAvailable )

        {

        IssueNextAction( EExecuteCall );

        }

    else

        {

        IssueNextAction( EShowUnavailableNote );

        }

    }

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

// CPbk2AiwInterestItemCall::DoCancel

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

//

void CPbk2AiwInterestItemCall::DoCancel()

    {

    delete iContactLink;

    iContactLink = NULL;

    delete iRetriever;

    iRetriever = NULL;

	ixSPStoreContactsArray.ResetAndDestroy();

    }

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

// CPbk2AiwInterestItemCall::RunL

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

//

void CPbk2AiwInterestItemCall::RunL()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::RunL(%d)"), iState );

    switch ( iState )

        {

        case ERetrieveStoreContact:

            {

            RetrieveContactL();

            break;

            }

        case ERetrieveXSPContact:

            {

            RetrieveContactL();

            break;

            }

        case EExecuteCall:

            {

            MVPbkStoreContact* storeContact = const_cast<MVPbkStoreContact*>

                ( iControl->FocusedStoreContact() );

            if ( !storeContact )

                {

                storeContact = iStoreContact;

                }

            ExecuteCommandL( storeContact );

            break;

            }

        case EShowUnavailableNote:

            {

            if ( iStoreStateChecker )

                {

                iStoreStateChecker->ShowUnavailableNoteL();

                }

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse, Panic( EPanicLogic_UnknownState ) );

            break;

            }

        }

    }

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

// CPbk2AiwInterestItemCall::RunError

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

//

TInt CPbk2AiwInterestItemCall::RunError( TInt aError )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(

        "CPbk2AiwInterestItemCall::RunError(%d)"), aError );

    HandleError( aError );

    return KErrNone;

    }

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

// CPbk2AiwInterestItemCall::ExecuteCommandL

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

//

void CPbk2AiwInterestItemCall::ExecuteCommandL

        ( MVPbkStoreContact*& aStoreContact )

    {

    __ASSERT_DEBUG(iControl, Panic( EPanicPreCond_ExecuteCommandL ) );

    MPbk2Command* cmd = NULL;

    TBool launchTelephonyCall = ETrue;

    // Because send key is used also to launch POC calls

    // we have to verify what was the selection and is

    // it ok to launch a telephony call.

    // If command id is EPbk2CmdCall, then the call was launched

    // with the send key.

    if ( iMenuCommandId == EPbk2CmdCall )

        {

        TInt focusedFieldIndex = iControl->FocusedFieldIndex();

        if ( focusedFieldIndex != KErrNotFound )

            {

            MVPbkStoreContactField* focusedField =

                FocusedFieldLC( *aStoreContact, focusedFieldIndex );

            launchTelephonyCall = iSelector->OkToLaunchTelephonyCallL

                ( focusedField );

            CleanupStack::PopAndDestroy(); // focusedField

            }

        }

    else if (iMenuCommandId == EPbk2CmdPrepend)

        {

        cmd = CreatePrependCmdObjectL(

                iMenuCommandId, *iControl, aStoreContact );

        }

    if ( !cmd )

        {

        if ( launchTelephonyCall )

            {

            cmd = CreateCallCmdObjectL

                ( iMenuCommandId, *iControl, aStoreContact );

            }

        else

            {

            cmd = CreatePocCmdObjectL

                ( iMenuCommandId, *iControl, *aStoreContact, NULL );

            }

        }

    if (cmd)

        {

        // Execute the command

        cmd->ExecuteLD();

        }

    }

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

// CPbk2AiwInterestItemCall::CreateCallCmdObjectL

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

//

MPbk2Command* CPbk2AiwInterestItemCall::CreateCallCmdObjectL

        ( const TInt aMenuCommandId, MPbk2ContactUiControl& aControl,

        MVPbkStoreContact*& aStoreContact )

    {

    // We need a bunch of pre-initialized variables

    MPbk2Command* cmd = NULL;

    MVPbkStoreContactField* selectedField = NULL;

    TBool okToLaunchTelephonyCall = ETrue;

    TBool selectAccepted = ETrue;

    VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector action

        ( VPbkFieldTypeSelectorFactory::EEmptySelector );

    AssignFocusedFieldL( aControl, *aStoreContact );

    if ( aMenuCommandId == EPbk2CmdCall )

        {

        // Call launched with send key, an address select needs

        // to be constructed

        TResourceReader resReader;        

        TInt resourceId = R_PBK2_SEND_KEY_ADDRESS_SELECT;

        if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

        	{

        	resourceId = R_PBK2_SEND_KEY_ADDRESS_SELECT_VOIP;

        	}

        CCoeEnv::Static()->CreateResourceReaderLC

            ( resReader, resourceId );

        TPbk2AddressSelectParams params(

            *aStoreContact,

            iAppUi->ApplicationServices().ContactManager(),

            iAppUi->ApplicationServices().NameFormatter(),

            *iFieldPropertyArray,

            resReader,

            R_QTN_PHOB_QTL_CALL_TO_NAME );

        RVPbkContactFieldDefaultPriorities defaultPrioritiesArray;

        CVPbkFieldTypeSelector* actionTypeSelector = NULL;

        CSPSettingsVoIPUtils* sPSettings = CSPSettingsVoIPUtils::NewLC();

        // IsVoIPSupported() is used for checking whether the platfrom supports VOIP.

        // If the service has been defined, then the specific call should be shown.

        // If the platform supports VOIP and its address has been defined.

        // Then, internet calls and voip calls can be made.

        if ( sPSettings->IsVoIPSupported() && sPSettings->VoIPProfilesExistL() )

            {

            action = VPbkFieldTypeSelectorFactory::EVOIPCallSelector;

            actionTypeSelector = VPbkFieldTypeSelectorFactory::BuildContactActionTypeSelectorL(

                    VPbkFieldTypeSelectorFactory::EVOIPCallSelector,

                    iAppUi->ApplicationServices().ContactManager().FieldTypes());