/*

* 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 <CVPbkFieldTypeSelector.h>

#include <CVPbkFieldFilter.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 {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPreCond_LaunchServicePhaseL = 1,

    EPanicPreCond_ContactOperationComplete,

    EPanicPreCond_RetrieveContactL,

    EPanicPreCond_DoSelectAddressesL

    };

static void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2CommAddressSelectPhase");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

// 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 ),

            iState( EInitialState ),

            iCommMethod( aCommSelector )

    {

    }

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

// 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() );

    }

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

// 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()

    {

    __ASSERT_DEBUG( iState == EInitialState, 

            Panic( EPanicPreCond_LaunchServicePhaseL ) );

    RetrieveContactL();

    }

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

// CPbk2CommAddressSelectPhase::CancelServicePhase

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

//

void CPbk2CommAddressSelectPhase::CancelServicePhase()

    {

    if ( iAddressSelectEliminator != NULL )

        {

        iAddressSelectEliminator->ForceExit();

        }

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    if ( iContactPresence )

    	{

		iContactPresence->CancelAll();

    	}

    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 )

    {

    __ASSERT_DEBUG( iState == EInitialState || iState == ExSPLinksRetrieved ||

            iState == ExSPContactRetrieved, 

            Panic( EPanicPreCond_ContactOperationComplete ) );

    if ( iState == EInitialState )

        {

        iState = EMainContactRetrieved;

        // Contact retrieval complete, take contact ownership

        delete iStoreContact;

        iStoreContact = aContact;

        StartLoadingxSPContactLinks();

        }

    else if ( iState == ExSPLinksRetrieved || iState == ExSPContactRetrieved )

        {

        iState = ExSPContactRetrieved;

        // xSP contact retrieval complete. Ignore errors, just try next one

        // or go to next state.

        /*TInt err = */ixSPStoreContactsArray.Append( aContact );

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

        if ( ixSPContactsArray->Count() > 0 )

            {

            RetrieveContact();

            }

        else

            {

            iState = ExSPContactsRetrieved;

            StartLoadingPresenceIconInfo();

            }

        }

    }

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

// 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

    DoSelectAddresses();

    }

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

// CPbk2CommAddressSelectPhase::VPbkOperationResultCompleted

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

//

void CPbk2CommAddressSelectPhase::VPbkOperationResultCompleted(

    MVPbkContactOperationBase* /*aOperation*/,

    MVPbkContactLinkArray* aArray )

    {

    iState = ExSPLinksRetrieved;

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

        {

        StartLoadingPresenceIconInfo();

        }

    else

        {

		StartLoadingxSPContacts( *aArray );

        }

    }

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

// 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 )

    {

	iState = EPresenceIconRetrieved;

    // 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 )

            {

            if ( !iPresenceIconArray[i]->IconBitmap() )

                {

                iPresenceIconArray[i]->SetBitmap( aBrandedBitmap, aMask );

                break;

                }            

            }

        }

    // check if all icon files received

    iState = EPresenceIconsRetrieved;

    for ( TInt j = 0; j < count && iState == EPresenceIconsRetrieved; j++ )

        {

        if ( iPresenceIconArray[j]->IconBitmap() == NULL ||

             iPresenceIconArray[j]->IconBitmapMask() == NULL )

            {

            // Not all retrieved, still in state  EPresenceIconRetrieved.

            iState = EPresenceIconRetrieved;

            }

        }

    // start address fetch dialog, if it waits for presence icons

    if ( iState == EPresenceIconsRetrieved )

        {

        DoSelectAddresses();

        }

    }

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

// CPbk2CommAddressSelectPhase::PresenceSubscribeError

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

//

void CPbk2CommAddressSelectPhase::PresenceSubscribeError(

            const TDesC8& /*aPackedLink*/,

            TInt /*aStatus*/ )

    {

    // nothing to do

    }

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

// CPbk2CommAddressSelectPhase::ErrorOccured

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

//

void CPbk2CommAddressSelectPhase::ErrorOccured(

            TInt /*aOpId*/,

            TInt /*aStatus*/ )

    {