/*

* 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 server app address select phase.

*

*/

#include "CPbk2CommAddressSelectPhase.h"

// Phonebook 2

#include "MPbk2ServicePhaseObserver.h"

#include "CPbk2ServerAppAppUi.h"

#include "CPbk2KeyEventDealer.h"

#include <MPbk2DialogEliminator.h>

#include <CPbk2AddressSelect.h>

#include <TPbk2AddressSelectParams.h>

#include <MPbk2ApplicationServices.h>

#include <CPbk2PresenceIconInfo.h>

#include <Pbk2UIControls.rsg>

#include <Pbk2Commands.rsg>

#include <CPbk2StoreManager.h> 

// Virtual Phonebook

#include <MVPbkContactLink.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactManager.h>

#include <VPbkFieldTypeSelectorFactory.h>

#include <CVPbkxSPContacts.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldUriData.h>

#include <CVPbkFieldTypeRefsList.h>

#include <CVPbkContactFieldIterator.h>

#include <VPbkEng.rsg>

// System includes

#include <barsread.h>

#include <avkon.rsg>

#include <contactpresencefactory.h>

#include <mcontactpresence.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlists.h>

/// Unnamed namespace for local definitions

namespace {

// Separator between service name and user's id in the service name returned

// in presence icon info.

_LIT( KServiceNameSeparator, ":");

const TInt KMaxXspServiceCount = 5;

/**

 * 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

        }

    }

struct TMap

    {

    VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector selector;

    TInt resId;

    };

const TMap KFieldMapTable[] = {

    { VPbkFieldTypeSelectorFactory::EVoiceCallSelector, R_PBK2_CALL_ITEM_NUMBER_SELECT },

    { VPbkFieldTypeSelectorFactory::EUniEditorSelector, R_PBK2_GENERIC_ADDRESS_SELECT },

    { VPbkFieldTypeSelectorFactory::EEmailEditorSelector, R_PBK2_EMAIL_ADDRESS_SELECT },

    { VPbkFieldTypeSelectorFactory::EInstantMessagingSelector, R_PBK2_GENERIC_ADDRESS_SELECT },

    { VPbkFieldTypeSelectorFactory::EVOIPCallSelector, R_PBK2_VOIP_ADDRESS_SELECT },

    { VPbkFieldTypeSelectorFactory::EURLSelector, R_PBK2_URL_ADDRESS_SELECT },

    { VPbkFieldTypeSelectorFactory::EVideoCallSelector, R_PBK2_VIDEO_NUMBER_SELECT },

    { VPbkFieldTypeSelectorFactory::EPocSelector, R_PBK2_POC_ADDRESS_SELECT }

};

const TInt KFieldMapTableLength = sizeof( KFieldMapTable ) / sizeof( TMap );

TInt AddressSelectResourceId

    ( VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector aType )

    {

    TInt resourceId = KErrNotFound;

    for( TInt i = 0; i < KFieldMapTableLength; i++ )

        {

        if( aType == KFieldMapTable[i].selector )

            {

            resourceId = KFieldMapTable[i].resId;

            break;

            }

        }

    return resourceId;

    }

} /// namespace

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

// CPbk2CommAddressSelectPhase::CPbk2CommAddressSelectPhase

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

//

CPbk2CommAddressSelectPhase::CPbk2CommAddressSelectPhase

        ( MPbk2ServicePhaseObserver& aObserver,

          RVPbkContactFieldDefaultPriorities& aPriorities,

          TBool aRskBack,

          CVPbkFieldTypeSelector& aFieldTypeSelector,

          VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector

                aCommSelector  ) :

            iObserver( aObserver ),

            iPriorities( aPriorities ),

            iRskBack( aRskBack ),

            iFieldTypeSelector ( aFieldTypeSelector ),

    {

    }

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

// CPbk2CommAddressSelectPhase::~CPbk2CommAddressSelectPhase

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

//

CPbk2CommAddressSelectPhase::~CPbk2CommAddressSelectPhase()

    {

    if ( iAddressSelectEliminator != NULL )

        {

        iAddressSelectEliminator->ForceExit();

        }

    delete iStoreContact;

    delete iRetrieveOperation;

    delete iContactLink;

    delete iResults;

    delete iDealer;

    delete ixSPManager;

    delete ixSPContactOperation;

    delete ixSPContactsArray;

    ixSPStoreContactsArray.ResetAndDestroy();

    delete iFieldContent;

    if( iContactPresence )

        {

        iContactPresence->Close();

        iContactPresence = NULL;

        }

    iPresenceIconArray.ResetAndDestroy();

    }

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

// CPbk2CommAddressSelectPhase::ConstructL

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

//

inline void CPbk2CommAddressSelectPhase::ConstructL

    ( const MVPbkContactLink& aContactLink )

    {

    iEikenv = CEikonEnv::Static();

    // Copy contact link provided by the client

    MVPbkContactLink* link = aContactLink.CloneLC();

    User::LeaveIfNull( link );

    CleanupStack::Pop(); //link

    iContactLink = link;

    iDealer = CPbk2KeyEventDealer::NewL( *this );

    // Map TVPbkFieldTypeSelector to resource id

    iResourceId = AddressSelectResourceId( iCommMethod );

    if ( iResourceId == KErrNotFound )

        {

        User::LeaveIfError( KErrArgument );

        }

    // Create xSP contacts manager

    CPbk2ServerAppAppUi& appUi =

        static_cast<CPbk2ServerAppAppUi&>(*CEikonEnv::Static()->EikAppUi());

    ixSPManager = CVPbkxSPContacts::NewL(

         appUi.ApplicationServices().ContactManager() );

    // Create contact presence manager if chat fields should be shown

    if ( ( iCommMethod ==

            VPbkFieldTypeSelectorFactory::EInstantMessagingSelector ) ||

            ( iCommMethod ==

                        VPbkFieldTypeSelectorFactory::EVOIPCallSelector ) )

        {

        iContactPresence = TContactPresenceFactory::NewContactPresenceL(

            *this );

        // ...and start presence icons retrieving

        HBufC8* packedLink = iContactLink->PackLC();

        TInt opId = iContactPresence->GetPresenceInfoL( *packedLink );

        CleanupStack::PopAndDestroy( packedLink );

        }

    else

        {

        iPresenceIconsRetrieved = ETrue;

        }

    }

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

// CPbk2CommAddressSelectPhase::NewL

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

//

CPbk2CommAddressSelectPhase* CPbk2CommAddressSelectPhase::NewL

        ( MPbk2ServicePhaseObserver& aObserver,

          const MVPbkContactLink& aContactLink,

          RVPbkContactFieldDefaultPriorities& aPriorities,

          CVPbkFieldTypeSelector& aFieldTypeSelector,

          VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector

            aCommSelector,

          TBool aRskBack )

    {

    CPbk2CommAddressSelectPhase* self = new ( ELeave )

        CPbk2CommAddressSelectPhase( aObserver, aPriorities, aRskBack,

            aFieldTypeSelector, aCommSelector );

    CleanupStack::PushL( self );

    self->ConstructL( aContactLink );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2CommAddressSelectPhase::LaunchServicePhaseL

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

//

void CPbk2CommAddressSelectPhase::LaunchServicePhaseL()

    {

    // Start by retrieving first contact

    iState = EMainContactRetrieving;

    RetrieveContactL();

    }

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

// CPbk2CommAddressSelectPhase::CancelServicePhase

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

//

void CPbk2CommAddressSelectPhase::CancelServicePhase()

    {

    if ( iAddressSelectEliminator != NULL )

        {

        iAddressSelectEliminator->ForceExit();

        }

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    iObserver.PhaseCanceled( *this );

    }

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

// CPbk2CommAddressSelectPhase::RequestCancelL

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

//

void CPbk2CommAddressSelectPhase::RequestCancelL( TInt aExitCommandId )

    {

    if ( iAddressSelectEliminator != NULL )

        {

        iAddressSelectEliminator->RequestExitL( aExitCommandId );

        }

    // Withdraw our key event agent so that it does not react to

    // app shutter's escape key event simulation

    delete iDealer;

    iDealer = NULL;

   if ( aExitCommandId == EEikBidCancel )

        {

        iObserver.PhaseAborted( *this );

        }

    else

        {

        iObserver.PhaseCanceled( *this );

        }

    }

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

// CPbk2CommAddressSelectPhase::AcceptDelayed

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

//

void CPbk2CommAddressSelectPhase::AcceptDelayedL

        ( const TDesC8& /*aContactLinkBuffer*/ )

    {

    // Nothing to accept

    }

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

// CPbk2CommAddressSelectPhase::Results

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

//

MVPbkContactLinkArray* CPbk2CommAddressSelectPhase::Results() const

    {

    return iResults;

    }

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

// CPbk2CommAddressSelectPhase::ExtraResultData

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

//

TInt CPbk2CommAddressSelectPhase::ExtraResultData() const

    {

    return KErrNotSupported;

    }

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

// CPbk2CommAddressSelectPhase::TakeStoreContact

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

//

MVPbkStoreContact* CPbk2CommAddressSelectPhase::TakeStoreContact()

    {

    MVPbkStoreContact* contact = iStoreContact;

    iStoreContact = NULL;

    return contact;

    }

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

// CPbk2CommAddressSelectPhase::FieldContent

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

//

HBufC* CPbk2CommAddressSelectPhase::FieldContent() const

    {

    return iFieldContent;

    }

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

// CPbk2CommAddressSelectPhase::VPbkSingleContactOperationComplete

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

//

void CPbk2CommAddressSelectPhase::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& /*aOperation*/,

          MVPbkStoreContact* aContact )

    {

    if ( iState == EMainContactRetrieving )

        {

        // Contact retrieval complete, take contact ownership

        delete iStoreContact;

        iStoreContact = aContact;

        // Start fetching xSP contact links

        iState = ExSPLinksRetrieving;

        TRAPD( err,

            ixSPContactOperation = ixSPManager->GetxSPContactLinksL(

                *iStoreContact, *this, *this );

             );

        if ( err != KErrNone )

            {

            // Run the address select dialog for the main contact at least

            TRAPD( err, DoSelectAddressesL() );

            if ( err != KErrNone )

                {

                iObserver.PhaseError( *this, err );

                }

            iState = EDialogWaitsUserInput;

            }

        }

    if ( iState == ExSPContactsRetrieving )

        {

        // xSP contact retrieval complete

        TInt err = ixSPStoreContactsArray.Append( aContact );

        // If error, stop retrieving xSP contacts and show address select

        // dialog.

        // Start retrieving next xSP contact, if there are some contacts left

        if ( ixSPContactsArray->Count() != 0 && err == KErrNone )

            {

            TRAP( err, RetrieveContactL(); );

            if ( err != KErrNone )

                {

                iState = EDialogWaitsUserInput;

                }

            }

        else

            {

            FilterXspContactsL();            

            // Run the address select, if no more contacts to retrieve

            TRAP( err, DoSelectAddressesL() );

            if ( err != KErrNone )

                {

                iObserver.PhaseError( *this, err );

                }

            }

        }

    }

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

// CPbk2CommAddressSelectPhase::VPbkSingleContactOperationFailed

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

//

void CPbk2CommAddressSelectPhase::VPbkSingleContactOperationFailed

        ( MVPbkContactOperationBase& /*aOperation*/, TInt aError )

    {

    iObserver.PhaseError( *this, aError );

    }

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

// CPbk2CommAddressSelectPhase::Pbk2ProcessKeyEventL

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

//

TBool CPbk2CommAddressSelectPhase::Pbk2ProcessKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TBool ret = EFalse;

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

        {

        iObserver.PhaseOkToExit( *this, EEikBidCancel );

        ret = ETrue;

        }

    return ret;

    }

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

// CPbk2CommAddressSelectPhase::VPbkOperationFailed

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

//

void CPbk2CommAddressSelectPhase::VPbkOperationFailed(

    MVPbkContactOperationBase* /*aOperation*/, TInt /*aError*/ )

    {

    // Ignore an error, xSP info can be omitted. Just run address select dialog

    TRAPD( err, DoSelectAddressesL() );

    if ( err != KErrNone )

       {

       iObserver.PhaseError( *this, err );

       }

    iState = EDialogWaitsUserInput;

    }

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

// CPbk2CommAddressSelectPhase::VPbkOperationResultCompleted

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

//

void CPbk2CommAddressSelectPhase::VPbkOperationResultCompleted(

    MVPbkContactOperationBase* /*aOperation*/,

    MVPbkContactLinkArray* aArray )

    {

    if ( aArray == NULL || aArray->Count() == 0 )

        {

        // No xSP contacts, run address select dialog

        TRAPD( err, DoSelectAddressesL() );

        if ( err != KErrNone )

            {

            iObserver.PhaseError( *this, err );

            }

        }

    else

        {

        TRAPD( err,

            // Take a own copy of supplied contact links

            ixSPContactsArray = CVPbkContactLinkArray::NewL();

            CopyContactLinksL( *aArray, *ixSPContactsArray );

            // Start fetching xSP contacts

            iState = ExSPContactsRetrieving;

            RetrieveContactL();

            );

        // If error happened, show address select dialog

        if ( err != KErrNone )

            {

            TRAP( err, DoSelectAddressesL() );

            if ( err != KErrNone )

                {

                iObserver.PhaseError( *this, err );

                }

            }

        ixSPStoreContactsArray.ResetAndDestroy();

        }

    }

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

// CPbk2CommAddressSelectPhase::ReceiveIconInfoL

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

//

void CPbk2CommAddressSelectPhase::ReceiveIconInfoL(

            const TDesC8& /*aPackedLink*/,

            const TDesC8& /*aBrandId*/,

            const TDesC8& /*aElementId*/ )

    {

    // nothing to do

    }

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

// CPbk2CommAddressSelectPhase::ReceiveIconFileL

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

//

void CPbk2CommAddressSelectPhase::ReceiveIconFileL(

            const TDesC8& aBrandId,

            const TDesC8& aElementId,

            CFbsBitmap* aBrandedBitmap,

            CFbsBitmap* aMask )

    {

    if ( iPresenceIconsRetrieved )

        {

        // icons retrieving failed before, no need to take care about

        // presence icons anymore

        return;

        }

    // icon file received, save it to icon info array

    TInt count = iPresenceIconArray.Count();    

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

        {

        if ( iPresenceIconArray[i]->BrandId().CompareF( aBrandId ) == 0 &&

             iPresenceIconArray[i]->ElementId().CompareF( aElementId ) == 0 )

            {