/*

* 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 application server item fetcher.

*

*/

#include "CPbk2ItemFetcher.h"

// Phonebook 2

#include "MPbk2UiServiceObserver.h"

#include "TPbk2ServerMessageDataRetriever.h"

#include "CPbk2ServerAppAppUi.h"

#include "TPbk2TitlePaneOperator.h"

#include "CPbk2ServerAppStoreManager.h"

#include "CPbk2ContactFetchPhase.h"

#include "CPbk2AddressSelectPhase.h"

#include <CPbk2StoreManager.h>

#include <Pbk2UIControls.rsg>

#include <TPbk2AddressSelectParams.h>

#include <Pbk2IPCPackage.h>

#include <MPbk2ApplicationServices.h>

#include "CPbk2CommAddressSelectPhase.h"

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkStoreContact.h>

#include <CVPbkFieldTypeSelector.h>

#include <MVPbkContactStore.h>

#include <MVPbkStoreContact.h>

#include <TVPbkContactStoreUriPtr.h>

// System includes

#include <avkon.rsg>

#include <spsettings.h>

#include <spproperty.h>

// Debug

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

/**

 * Sets title pane.

 *

 * @param aDataRetriever    Server message data retriever.

 * @param aFlags            Fetch flags.

 * @param aMessage          Server message.

 */

void SetTitlePaneL

        ( TPbk2ServerMessageDataRetriever& aDataRetriever, TUint aFlags,

          const RMessage2& aMessage )

    {

    HBufC* titlePaneText = NULL;

    if ( !( aFlags & ::EUseProviderTitle ) )

        {

        titlePaneText = aDataRetriever.GetTitlePaneTextL( aMessage );

        }

    TPbk2TitlePaneOperator titlePaneOperator;

    titlePaneOperator.SetTitlePaneL( titlePaneText ); // takes ownership

    }

struct TMap

    {

    TAiwCommAddressSelectType aiwType;

    VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector selectorType;

    };

const TMap KAiwMapTable[] = {

    { EAiwCommEmpty,            VPbkFieldTypeSelectorFactory::EEmptySelector },

    { EAiwCommVoiceCall,        VPbkFieldTypeSelectorFactory::EVoiceCallSelector },

    { EAiwCommUniEditor,        VPbkFieldTypeSelectorFactory::EUniEditorSelector },

    { EAiwCommEmailEditor,      VPbkFieldTypeSelectorFactory::EEmailEditorSelector },

    { EAiwCommInstantMessaging, VPbkFieldTypeSelectorFactory::EInstantMessagingSelector },

    { EAiwCommVOIPCall,         VPbkFieldTypeSelectorFactory::EVOIPCallSelector },

    { EAiwCommURL,              VPbkFieldTypeSelectorFactory::EURLSelector },

    { EAiwCommVideoCall,        VPbkFieldTypeSelectorFactory::EVideoCallSelector }

};

const TInt KAiwMapTableLength = sizeof( KAiwMapTable ) / sizeof( TMap ); 

VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector

    MapToCommSelectorType( TAiwCommAddressSelectType aAiwType )

    {

    VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector selector =

        VPbkFieldTypeSelectorFactory::EEmptySelector;

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

        {

        if( aAiwType == KAiwMapTable[i].aiwType)

            {

            selector = KAiwMapTable[i].selectorType;

            break;

            }

        }

    return selector;

    }

CVPbkFieldTypeSelector* BuildFilterL(

        TAiwAddressSelectType aType,

        const MVPbkFieldTypeList& aFieldTypeList )

    {

    CVPbkFieldTypeSelector* selector = NULL;

    switch( aType )

        {

        case EAiwMMSSelect:

            {

            selector = VPbkFieldTypeSelectorFactory::

                BuildContactActionTypeSelectorL(

                    VPbkFieldTypeSelectorFactory::EUniEditorSelector,

                    aFieldTypeList );

            break;

            }

        case EAiwEMailSelect:

            {

            selector = VPbkFieldTypeSelectorFactory::

                BuildContactActionTypeSelectorL(

                    VPbkFieldTypeSelectorFactory::EEmailEditorSelector,

                    aFieldTypeList );

            break;

            }        

        case EAiwVideoNumberSelect:

            {

            selector = VPbkFieldTypeSelectorFactory::

                BuildContactActionTypeSelectorL(

                    VPbkFieldTypeSelectorFactory::EVideoCallSelector,

                    aFieldTypeList );

            break;

            }

        case EAiwVOIPSelect:

            {

            selector = VPbkFieldTypeSelectorFactory::

                BuildContactActionTypeSelectorL(

                    VPbkFieldTypeSelectorFactory::EVOIPCallSelector,

                    aFieldTypeList );

            }

        break;

        default:

            break;

        }

    return selector;

    }

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicLogicPhaseCompletion = 1

    };

void Panic( TPanicCode aReason )

    {

    _LIT( KPanicText, "CPbk2ItemFetcher" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

} /// namespace

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

// CPbk2ItemFetcher::CPbk2ItemFetcher

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

//

CPbk2ItemFetcher::CPbk2ItemFetcher

        ( MPbk2UiServiceObserver& aObserver,

          TPbk2FetchType aFetchType ) :

            iObserver( aObserver ),

            iFetchType( aFetchType )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::CPbk2ItemFetcher()") );

    }

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

// CPbk2ItemFetcher::~CPbk2ItemFetcher

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

//

CPbk2ItemFetcher::~CPbk2ItemFetcher()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::~CPbk2ItemFetcher()") );

    delete iStoreUris;

    delete iContactFetchStoreUris;

    delete iPreselectedContacts;

    delete iContactViewFilter;

    iDefaultPriorities.Close();

    delete iStoreManager;

    delete iFetchPhase;

    delete iAddressSelectPhase;

    delete iCommAddressSelectPhase;

    }

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

// CPbk2ItemFetcher::NewL

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

//

CPbk2ItemFetcher* CPbk2ItemFetcher::NewL

        ( const RMessage2& aFetchCompleteMessage,

          MPbk2UiServiceObserver& aObserver,

          TPbk2FetchType aFetchType )

    {

    CPbk2ItemFetcher* self =

        new ( ELeave ) CPbk2ItemFetcher( aObserver, aFetchType );

    CleanupStack::PushL( self );

    self->ConstructL( aFetchCompleteMessage );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ItemFetcher::ConstructL

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

//

inline void CPbk2ItemFetcher::ConstructL( const RMessage2& aMessage )

    {

    // Retrieve data from the client-server message

    CPbk2ServerAppAppUi& appUi =

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

    TPbk2ServerMessageDataRetriever dataRetriever;

    TUint flags = dataRetriever.FetchFlagsL( aMessage );

    // Set title pane

    SetTitlePaneL( dataRetriever, flags, aMessage );

    iPreselectedContacts = dataRetriever.GetPreselectedContactLinksL

        ( aMessage, appUi.ApplicationServices().ContactManager() );

    iStoreUris = dataRetriever.GetContactStoreUriArrayL

        ( aMessage, appUi.ApplicationServices().StoreConfiguration(),

          iPreselectedContacts, iUseDeviceConfig );

    // Contact fetch store uris, not including xSP stores

    iContactFetchStoreUris = CVPbkContactStoreUriArray::NewL();

    iContactFetchStoreUris->AppendAllL(*iStoreUris); 

    TAiwCommAddressSelectType selectorType = 

        dataRetriever.GetCommAddressSelectTypeL( aMessage );

    iCommAddressSelectType = MapToCommSelectorType( selectorType );

    iAddressSelectType = dataRetriever.GetAddressSelectTypeL( aMessage );

    // Create contact filters

    if ( iCommAddressSelectType != VPbkFieldTypeSelectorFactory::EEmptySelector )

        {

        iContactViewFilter = VPbkFieldTypeSelectorFactory::

        	BuildContactActionTypeSelectorL( iCommAddressSelectType,

                appUi.ApplicationServices().ContactManager().FieldTypes() );

        }

    // Phonebook specific filters take prefference over the

    // filter specified by client

    else

        {

        iContactViewFilter = BuildFilterL( iAddressSelectType,

                appUi.ApplicationServices().ContactManager().FieldTypes() );

        // Filter specified by client

        if ( iContactViewFilter == NULL )

            {

            iContactViewFilter = dataRetriever.GetContactViewFilterL

                ( aMessage, appUi.ApplicationServices().ContactManager().

                  FieldTypes() );

            }

        }

    iFetchResId = dataRetriever.GetFetchDialogResourceL( aMessage );

    iStoreManager = CPbk2ServerAppStoreManager::NewL

        ( appUi.StoreManager(),

          appUi.ApplicationServices().ContactManager() );

    if ( iCommAddressSelectType != VPbkFieldTypeSelectorFactory::EEmptySelector )

        {

        GetDefaultPriorities( flags );

        }

    else

        {

        iDefaultPriorities = dataRetriever.FetchDefaultPrioritiesL( aMessage );

        }

    if ( iCommAddressSelectType != VPbkFieldTypeSelectorFactory::EEmptySelector )

        {

        // add also xSP stores to the store list

        AddXSPStoresL();

        }

    }

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

// CPbk2ItemFetcher::LaunchServiceL

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

//

void CPbk2ItemFetcher::LaunchServiceL()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::LaunchServiceL()") );

    iStoreManager->LoadAndOpenContactStoresL( *iStoreUris, *this, EFalse );

    }

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

// CPbk2ItemFetcher::CancelService

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

//

void CPbk2ItemFetcher::CancelService()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::CancelService()") );

    if ( iFetchPhase )

        {

        iFetchPhase->CancelServicePhase();

        }

    if ( iAddressSelectPhase )

        {

        iAddressSelectPhase->CancelServicePhase();

        }

   if ( iCommAddressSelectPhase )

        {

        iCommAddressSelectPhase->CancelServicePhase();

        }

    }

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

// CPbk2ItemFetcher::AcceptDelayedContactsL

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

//

void CPbk2ItemFetcher::AcceptDelayedContactsL

        ( const TDesC8& aContactLinkBuffer )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::AcceptDelayedContactsL()") );

    if ( iAddressSelectPhase )

        {

        iAddressSelectPhase->AcceptDelayedL( aContactLinkBuffer );

        }

    if ( iCommAddressSelectPhase )

        {

        iCommAddressSelectPhase->AcceptDelayedL( aContactLinkBuffer );

        }

    if ( iFetchPhase )

        {

        iFetchPhase->AcceptDelayedL( aContactLinkBuffer );

        }

    }

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

// CPbk2ItemFetcher::ExitServiceL

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

//

void CPbk2ItemFetcher::ExitServiceL( TInt aExitCommandId )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::ExitServiceL(%d)"), aExitCommandId );

    if ( iAddressSelectPhase )

        {

        iAddressSelectPhase->RequestCancelL( aExitCommandId );

        // Report fetch aborting and close application

        iObserver.ServiceAborted();

        }

    if ( iCommAddressSelectPhase )

        {

        iCommAddressSelectPhase->RequestCancelL( aExitCommandId );

        // Report fetch aborting and close application

        iObserver.ServiceAborted();

        }

    if ( iFetchPhase )

        {

        iFetchPhase->RequestCancelL( aExitCommandId );

        }

    }

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

// CPbk2ItemFetcher::ServiceResults

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

//

void CPbk2ItemFetcher::ServiceResults(TServiceResults* aResults) const

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::ServiceResults()") );

    if ( iAddressSelectPhase )

        {

        aResults->iLinkArray = iAddressSelectPhase->Results();

        aResults->iExtraData = iAddressSelectPhase->ExtraResultData();

        aResults->iFieldContent = NULL;

        }

    if ( iCommAddressSelectPhase )

        {

        aResults->iLinkArray = iCommAddressSelectPhase->Results();

        aResults->iExtraData = iCommAddressSelectPhase->ExtraResultData();

        aResults->iFieldContent = iCommAddressSelectPhase->FieldContent();

        }

    }

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

// CPbk2ItemFetcher::NextPhase

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

//

void CPbk2ItemFetcher::NextPhase( MPbk2ServicePhase& aPhase )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::NextPhase()") );

    if ( &aPhase == iFetchPhase )

        {

        MVPbkContactLinkArray* fetchResult = iFetchPhase->Results();

        __ASSERT_DEBUG( fetchResult && fetchResult->Count() > 0,

            Panic( EPanicLogicPhaseCompletion ) );

        TRAPD( err, LaunchAddressSelectPhaseL( *fetchResult ) );

        if ( err != KErrNone )

            {

            iObserver.ServiceError( err );

            }

        }

    else if ( &aPhase == iAddressSelectPhase || 

              &aPhase == iCommAddressSelectPhase )

        {

        // Address select was the last phase

        iObserver.ServiceComplete();

        }

    else

        {

        __ASSERT_DEBUG( EFalse, Panic( EPanicLogicPhaseCompletion ) );

        }

    }

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

// CPbk2ItemFetcher::PreviousPhase

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

//

void CPbk2ItemFetcher::PreviousPhase( MPbk2ServicePhase& /*aPhase*/ )

    {

    // Do nothing

    }

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

// CPbk2ItemFetcher::PhaseCanceled

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

//

void CPbk2ItemFetcher::PhaseCanceled( MPbk2ServicePhase& aPhase )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2ItemFetcher::PhaseCanceled()") );

    // We cannot cancel the phase completely if the cancellation

    // was done from address phase and fetch phase dialog still exists and

    // we are dealing with singleitemfetch

    if ( ( ( &aPhase != iAddressSelectPhase ) && 

         ( &aPhase != iCommAddressSelectPhase ) ) || 

         !iFetchPhase ||

         iFetchType == EMultipleItemFetch )

        {

        iObserver.ServiceCanceled();

        }

    }

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

// CPbk2ItemFetcher::PhaseAborted

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

//

void CPbk2ItemFetcher::PhaseAborted( MPbk2ServicePhase& /*aPhase*/ )

    {

    iObserver.ServiceAborted();

    }

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

// CPbk2ItemFetcher::PhaseError

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

//

void CPbk2ItemFetcher::PhaseError

        ( MPbk2ServicePhase& /*aPhase*/, TInt aErrorCode )

    {

    iObserver.ServiceError( aErrorCode );

    }

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

// CPbk2ItemFetcher::PhaseOkToExit

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

//

TBool CPbk2ItemFetcher::PhaseOkToExit

        ( MPbk2ServicePhase& /*aPhase*/, TInt aCommandId )

    {

    // Deny exit and pass an asynchronous query to the consumer,

    // which may later approve exit

    iObserver.CompleteExitMessage( aCommandId );

    return EFalse;

    }

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

// CPbk2ItemFetcher::PhaseAccept

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

//

void CPbk2ItemFetcher::PhaseAccept

        ( MPbk2ServicePhase& /*aPhase*/, const TDesC8& aMarkedEntries,

          const TDesC8& aLinkData )

    {

    iObserver.CompleteAcceptMsg( aMarkedEntries, aLinkData );

    }