/*
* 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 type selector.
*
*/


// INCLUDE FILES
#include "CPbk2CallTypeSelector.h"

// Phonebook 2
#include <MPbk2ContactUiControl.h>
#include <Pbk2Commands.hrh>
#include <pbk2uicontrols.rsg>
#include <TPbk2StoreContactAnalyzer.h>

// Virtual Phonebook
#include <CVPbkFieldTypeSelector.h>
#include <MVPbkBaseContactField.h>
#include <MVPbkStoreContact.h>
#include <MVPbkFieldType.h>
#include <CVPbkDefaultAttribute.h>
#include <CVPbkContactManager.h>
#include <RVPbkContactFieldDefaultPriorities.h>

// System includes
#include <coemain.h>
#include <centralrepository.h>
#include <AiwServiceHandler.h>
#include <AiwPoCParameters.hrh>
#include <featmgr.h>

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::CPbk2CallTypeSelector
// --------------------------------------------------------------------------
//
CPbk2CallTypeSelector::CPbk2CallTypeSelector
        ( CVPbkContactManager& aContactManager ) :
        iContactManager( aContactManager )
    {
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::~CPbk2CallTypeSelector
// --------------------------------------------------------------------------
//
CPbk2CallTypeSelector::~CPbk2CallTypeSelector()
    {
    FeatureManager::UnInitializeLib();
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::NewL
// --------------------------------------------------------------------------
//
CPbk2CallTypeSelector* CPbk2CallTypeSelector::NewL
        ( CVPbkContactManager& aContactManager )
    {
    CPbk2CallTypeSelector* self =
        new ( ELeave ) CPbk2CallTypeSelector( aContactManager );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2CallTypeSelector::ConstructL()
    {
    FeatureManager::InitializeLibL();
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectCallTypeL
// --------------------------------------------------------------------------
//
CAiwDialData::TCallType CPbk2CallTypeSelector::SelectCallTypeL
        ( const TInt aCommandId, MVPbkStoreContact& aContact,
          const MVPbkBaseContactField* aFocusedField,
          const MVPbkBaseContactField& aSelectedField ) const
    {
    // Default to voice call
    CAiwDialData::TCallType ret = CAiwDialData::EAIWVoice;

    // If the command was launched via Call UI menu we do not
    // need to apply our own logic for call type selection.
    // But if the command was not launched via menu but via the send key
    // (which is the case when aCommandId is EPbk2CmdCall), we
    // need to deduct what kind of a call to launch.
    if ( aCommandId == EPbk2CmdCall )
        {
        if ( !aFocusedField )
            {
            // If there was no focused field, the call was
            // launched from names list
            ret = SelectCallTypeL( aContact, aSelectedField );
            }
        else
            {
            // There was a focused field, so the
            // call was launched from info view
            ret = SelectCallTypeL( aSelectedField );
            }
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::OkToLaunchTelephonyCallL
// --------------------------------------------------------------------------
//
TBool CPbk2CallTypeSelector::OkToLaunchTelephonyCallL
        ( const MVPbkBaseContactField* aSelectedField ) const
    {
    // Default to yes
    TBool ret = ETrue;

    if ( aSelectedField )
        {
        TPbk2StoreContactAnalyzer analyzer( iContactManager, NULL );

        if ( analyzer.IsFieldTypeIncludedL( *aSelectedField,
                R_PHONEBOOK2_PTT_SELECTOR ) )
            {
            // In case of PTT field, a POC call is to be launched
            ret = EFalse;
            }
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectPocCallType
// --------------------------------------------------------------------------
//
TInt CPbk2CallTypeSelector::SelectPocCallType
        ( const MPbk2ContactUiControl& aControl ) const
    {
    TInt ret = 0;

    // Check are we in a contact info field (which has focused field)
    if ( !aControl.FocusedField() )
        {
        ret |= EAiwPoCCmdTalkMany;
        }

    if ( !aControl.ContactsMarked() )
        {
        ret |= EAiwPoCCmdTalk1to1 | EAiwPoCCmdSendCallBackRequest;
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectPocCallTypeForPocKeyPress
// --------------------------------------------------------------------------
//
TInt CPbk2CallTypeSelector::SelectPocCallTypeForPocKeyPress
        ( const MPbk2ContactUiControl& aControl ) const
    {
    TInt all = SelectPocCallType( aControl );
    TInt ret = all;

    // There is no specified logic for selecting a type.
    // So just define some priority for the call types.
    if ( all & EAiwPoCCmdTalkGroup )
        {
        ret = EAiwPoCCmdTalkGroup;
        }
    else if (all & EAiwPoCCmdTalk1to1)
        {
        ret = EAiwPoCCmdTalk1to1;
        }
    else if (all & EAiwPoCCmdTalkMany)
        {
        ret = EAiwPoCCmdTalkMany;
        }
    else if (all & EAiwPoCCmdSendCallBackRequest)
        {
        ret = EAiwPoCCmdSendCallBackRequest;
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SetDefaultPrioritiesLC
// --------------------------------------------------------------------------
//
void CPbk2CallTypeSelector::SetDefaultPrioritiesLC
        ( RVPbkContactFieldDefaultPriorities& aDefaults,
        MVPbkStoreContact& aContact ) const
    {
    CleanupClosePushL( aDefaults );

    if ( HasContactAttributeL( EVPbkDefaultTypePhoneNumber, aContact ) )
        {
        // Voice overrides everything else
        User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypePhoneNumber ) );
        }
    else if ( HasContactAttributeL( EVPbkDefaultTypeVoIP, aContact ) )
        {
        // VoIP overrides everything but voice
        User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypeVoIP ) );
        }
    else if ( HasContactAttributeL( EVPbkDefaultTypeVideoNumber, aContact ) )
        {
        // Video overrides POC
        User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypeVideoNumber ) );
        }
    else if ( HasContactAttributeL( EVPbkDefaultTypePOC, aContact ) )
        {
        // Only POC default exists, lets use it
        User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypePOC ) );
        }
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectCallTypeL
// Selects call type based on selected field and
// contacts default information.
// --------------------------------------------------------------------------
//
inline CAiwDialData::TCallType CPbk2CallTypeSelector::SelectCallTypeL
        ( MVPbkStoreContact& aContact,
          const MVPbkBaseContactField& aSelectedField ) const
    {
    // Default to voice call
    CAiwDialData::TCallType ret = CAiwDialData::EAIWVoice;

    if ( HasContactAttributeL( EVPbkDefaultTypePhoneNumber, aContact ) )
        {
        ret = CAiwDialData::EAIWVoice;
        }
    else if ( ( HasContactAttributeL( EVPbkDefaultTypeVoIP, aContact ) ) &&
                ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) )
        {
        ret = CAiwDialData::EAIWVoiP;
        }
    else if ( HasContactAttributeL( EVPbkDefaultTypeVideoNumber, aContact ) )
        {
        ret = CAiwDialData::EAIWForcedVideo;
        }
    else
        {
        // No defaults, so select based on selected field type only
        ret = SelectCallTypeBasedOnFieldTypeL( aSelectedField );
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectCallTypeL
// Select call type based on field type, the preferred telephony
// information setting is taken in consideration also.
// --------------------------------------------------------------------------
//
inline CAiwDialData::TCallType CPbk2CallTypeSelector::SelectCallTypeL
        ( const MVPbkBaseContactField& aSelectedField ) const
    {
    // When there is clearly a selected field, the call type
    // of course depends on the type of the field
    return SelectCallTypeBasedOnFieldTypeL( aSelectedField );
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectCallTypeBasedOnFieldTypeL
// This function selects the call type by the type of passed
// aSelectedField alone.
// --------------------------------------------------------------------------
//
inline CAiwDialData::TCallType
    CPbk2CallTypeSelector::SelectCallTypeBasedOnFieldTypeL
        ( const MVPbkBaseContactField& aSelectedField ) const
    {
    // Default to voice call
    CAiwDialData::TCallType ret = CAiwDialData::EAIWVoice;

    TPbk2StoreContactAnalyzer analyzer( iContactManager, NULL );

    if ( analyzer.IsFieldTypeIncludedL( aSelectedField,
            R_PHONEBOOK2_SIP_SELECTOR ) )
        {
        ret = CAiwDialData::EAIWVoiP;
        }
    else if ( analyzer.IsFieldTypeIncludedL( aSelectedField,
            R_PHONEBOOK2_VIDEO_SELECTOR ) )
        {
        ret = CAiwDialData::EAIWForcedVideo;
        }

    return ret;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::HasContactAttributeL
// Checks if aContact has default attribute of given type.
// --------------------------------------------------------------------------
//
TBool CPbk2CallTypeSelector::HasContactAttributeL
        ( TVPbkDefaultType aType, MVPbkStoreContact& aContact ) const
    {
    TBool retval = EFalse;

    CVPbkDefaultAttribute* attr = CVPbkDefaultAttribute::NewL( aType );
    CleanupStack::PushL( attr );
    MVPbkContactAttributeManager& attrManager =
        iContactManager.ContactAttributeManagerL();
    retval = attrManager.HasContactAttributeL( *attr, aContact );
    CleanupStack::PopAndDestroy( attr );

    return retval;
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SetDefaultPrioritiesLC
// --------------------------------------------------------------------------
//
void CPbk2CallTypeSelector::SetDefaultPrioritiesLC
        ( RVPbkContactFieldDefaultPriorities& aDefaults,
        MVPbkStoreContact& aContact,
        VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector aSelector ) const
    {
    CleanupClosePushL( aDefaults );

    switch( aSelector )
        {
        case VPbkFieldTypeSelectorFactory::EVoiceCallSelector :
            if ( HasContactAttributeL( EVPbkDefaultTypePhoneNumber, aContact ) )
                {
                User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypePhoneNumber ) );
                }
            break;
        case VPbkFieldTypeSelectorFactory::EVOIPCallSelector :
            if ( HasContactAttributeL( EVPbkDefaultTypeVoIP, aContact ) )
                {
                User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypeVoIP ) );
                }
            break;
        case VPbkFieldTypeSelectorFactory::EVideoCallSelector :
            if ( HasContactAttributeL( EVPbkDefaultTypeVideoNumber, aContact ) )
                {
                User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypeVideoNumber ) );
                }
            break;
        case VPbkFieldTypeSelectorFactory::EPocSelector :
            if ( HasContactAttributeL( EVPbkDefaultTypePOC, aContact ) )
                {
                User::LeaveIfError( aDefaults.Append( EVPbkDefaultTypePOC ) );
                }
            break;
        default:
            break;
        }
    }

// --------------------------------------------------------------------------
// CPbk2CallTypeSelector::SelectVoipCallTypeL
// --------------------------------------------------------------------------
//
CAiwDialData::TCallType CPbk2CallTypeSelector::SelectVoipCallTypeL(
        const MVPbkBaseContactField* aSelectedField ) const
    {
    // Default to CAiwDialData::EAIWVoiP
    CAiwDialData::TCallType ret = CAiwDialData::EAIWVoiP;

    TPbk2StoreContactAnalyzer analyzer( iContactManager, NULL );
    
    // Call type should be set CAiwDialData::EAIWVoice 
    // if mobile field (or other CS field) is selected 
    if ( analyzer.IsFieldTypeIncludedL( *aSelectedField,
    		R_PHONEBOOK2_VOIP_CALL_OUT_SELECTOR ) )
        {
        ret = CAiwDialData::EAIWVoice ;
        }
    
    return ret;
    }
        
// End of File