/*
* 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 );
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::ContactUiReadyL
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::ContactUiReadyL
        ( MPbk2StartupMonitor& aStartupMonitor )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
        ("CPbk2ItemFetcher::ContactUiReadyL()") );

    aStartupMonitor.DeregisterEvents( *this );

    if ( !iPreselectedContacts || iPreselectedContacts->Count() == 0 )
        {
        LaunchFetchPhaseL();
        }
    else
        {
        if ( iStoreManager->ContactsAvailableL( *iPreselectedContacts ) )
            {
            LaunchAddressSelectPhaseL( *iPreselectedContacts );
            }
        else
            {
            iObserver.ServiceError( KErrNotSupported );
            }
        }
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::StartupCanceled
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::StartupCanceled( TInt aErrorCode )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
        ("CPbk2ItemFetcher::StartupCanceled()"), aErrorCode );

    if ( aErrorCode == KErrCancel )
        {
        iObserver.ServiceCanceled();
        }
    else
        {
        iObserver.ServiceError( aErrorCode );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::LaunchFetchPhaseL
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::LaunchFetchPhaseL()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
        ("CPbk2ItemFetcher::LaunchFetchPhaseL()") );

    // By default fetch cannot exit
    TBool fetchOkToExit = EFalse;

    CPbk2FetchDlg::TParams params;
    params.iResId = R_PBK2_SINGLE_ENTRY_FETCH_DLG;
    params.iFlags = CPbk2FetchDlg::EFetchSingle;

    if ( iFetchType == ECallItemFetch )
        {
        params.iResId = R_PBK2_CALL_ITEM_FETCH_DLG;
        params.iFlags = CPbk2FetchDlg::EFetchCallItem;
        }
    else if ( iFetchType == EMultipleItemFetch )
        {
        params.iResId = R_PBK2_MULTIPLE_ENTRY_FETCH_DLG;
        params.iFlags = CPbk2FetchDlg::EFetchMultiple;

        // In multiple entry fetch, fetch can exit
        fetchOkToExit = ETrue;
        }

    delete iFetchPhase;
    iFetchPhase = NULL;
    iFetchPhase = CPbk2ContactFetchPhase::NewL
        ( *this, *iStoreManager, params, fetchOkToExit,
          MPbk2FetchDlgObserver::EFetchDelayed, iContactViewFilter,
          iUseDeviceConfig, iContactFetchStoreUris );

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

    // Change layout to fetch's layout
    appUi.ChangeStatuspaneLayoutL(
        CPbk2ServerAppAppUi::EStatusPaneLayoutUsual );

    iFetchPhase->LaunchServicePhaseL();
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::LaunchAddressSelectPhaseL
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::LaunchAddressSelectPhaseL
        ( MVPbkContactLinkArray& aContactLinks )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING
        ("CPbk2ItemFetcher::LaunchAddressSelectPhaseL()") );

    // By default RSK is 'Back'
    TBool rskBack = ETrue;

    // RSK is cancel in case of multiple item fetch
    // or if there are preselected contacts
    if ( iFetchType == EMultipleItemFetch )
        {
        rskBack = EFalse;
        }
    else if ( iPreselectedContacts && iPreselectedContacts->Count() != 0 )
        {
        rskBack = EFalse;
        }

    delete iAddressSelectPhase;
    iAddressSelectPhase = NULL;
    delete iCommAddressSelectPhase;
    iCommAddressSelectPhase = NULL;
    
    if ( iCommAddressSelectType != VPbkFieldTypeSelectorFactory::EEmptySelector )
        {
        iCommAddressSelectPhase = CPbk2CommAddressSelectPhase::NewL
            ( *this, aContactLinks.At( 0 ), iDefaultPriorities,
              *iContactViewFilter, iCommAddressSelectType, rskBack );

        iCommAddressSelectPhase->LaunchServicePhaseL();
        }
    else
        {
        iAddressSelectPhase = CPbk2AddressSelectPhase::NewL
            ( *this, aContactLinks, iDefaultPriorities,
            iAddressSelectType, rskBack );

        iAddressSelectPhase->LaunchServicePhaseL();
        }
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::AddXSPStoresL
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::AddXSPStoresL()
    {
    RIdArray ids;
    CleanupClosePushL( ids );
    CSPSettings* settings = CSPSettings::NewL();
    CleanupStack::PushL( settings ); 
    TInt error = settings->FindServiceIdsL( ids );  
    const TInt count = ids.Count();

    for( TInt i = 0; i < count; i++ )
        {
        CSPProperty* property = CSPProperty::NewLC();
        error = settings->FindPropertyL( ids[i], EPropertyContactStoreId,
            *property );
        if( KErrNone == error )
            {
            RBuf uri;
            uri.Create( KSPMaxDesLength );
            CleanupClosePushL( uri );  
            property->GetValue( uri );
            TVPbkContactStoreUriPtr uriPtr( uri );
            iStoreUris->AppendL( uriPtr );
            CleanupStack::PopAndDestroy();  //uri
            }
        CleanupStack::PopAndDestroy();  //property
        }
    CleanupStack::PopAndDestroy( 2 );  //settings, ids
    }

// --------------------------------------------------------------------------
// CPbk2ItemFetcher::GetDefaultPriorities
// --------------------------------------------------------------------------
//
void CPbk2ItemFetcher::GetDefaultPriorities( TUint aFlags )
    {
    if ( !( aFlags & ::EDoNotUseDefaultField ) )
        {
        switch ( iCommAddressSelectType )
            {
            // Errors during Append() operation are ignored, in this case 
            // address select dialog will be shown instead of immediate return
            // of the default field.
            case VPbkFieldTypeSelectorFactory::EVoiceCallSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypePhoneNumber );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EUniEditorSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeSms );
                iDefaultPriorities.Append( EVPbkDefaultTypeMms );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EVideoCallSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeVideoNumber );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EEmailEditorSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeEmail );
                break;    
                }
            case VPbkFieldTypeSelectorFactory::EVOIPCallSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeVoIP );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EPocSelector:
                {
                iDefaultPriorities.Append( EVPbkDefaultTypePOC );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EURLSelector :
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeOpenLink );
                break;
                }
            case VPbkFieldTypeSelectorFactory::EInstantMessagingSelector :
                {
                iDefaultPriorities.Append( EVPbkDefaultTypeChat );
                break;
                }
            default:
                {
                break;
                }
            }
        }
    }
// End of File
