/*

* Copyright (c) 2010 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:  A parameter class for setting call header information

*

*/

#include <mpeclientinformation.h>

#include <StringLoader.h>

#include <bautils.h>

#include "phonecallheaderutil.h"

#include "tphonecmdparamboolean.h"

#include "cphonemainresourceresolver.h"

#include "phonerssbase.h"

#include "phoneui.pan"

#include "cphonecenrepproxy.h"

#include "telephonyvariant.hrh"

#include "phoneviewcommanddefinitions.h"

#include "phonelogger.h"

// ======== MEMBER FUNCTIONS ========

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

// PhoneCallHeaderUtil::PhoneCallHeaderUtil

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

//  

PhoneCallHeaderUtil::PhoneCallHeaderUtil(

        MPEEngineInfo& engineInfo ) 

        : m_engineInfo( engineInfo),

          iCallHeaderType( EPECallTypeUninitialized ),

          iSetDivertIndication( EFalse ),

          iLabelText( NULL ),

          iEmergencyHeaderText( NULL ),

          iAttemptingEmergencyText( NULL )

    {

    }

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

// PhoneCallHeaderUtil::~PhoneCallHeaderUtil

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

//  

PhoneCallHeaderUtil::~PhoneCallHeaderUtil()

    {

    delete iLabelText;

    delete iEmergencyHeaderText;

    delete iAttemptingEmergencyText;

    }

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

// PhoneCallHeaderUtil::SetCallHeaderTexts

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

//

void PhoneCallHeaderUtil::SetCallHeaderTexts(

    const TInt aCallId, 

    const TBool aWaitingCall,

    const TBool aVideoCall,

    TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetCallHeaderTexts( ) ");

    TInt labelId(KPhoneRssCommonFirst);

    // Fetch engine info parameters.

    const TBool auxLine( m_engineInfo.CallALSLine( aCallId ) == CCCECallParameters::ECCELineTypeAux );

    const TBool cli( m_engineInfo.RemotePhoneNumber( aCallId ).Length());

    const TBool cnap( m_engineInfo.RemotePartyName( aCallId ).Length());

    const TInt numberType( m_engineInfo.RemotePhoneNumberType( aCallId ));

    __PHONELOG2( EBasic, EPhoneControl, "PhoneCallHeaderUtil::SetCallHeaderTexts - NumberType(%d), CLI(%d)", numberType, cli );

    __PHONELOG2( EBasic, EPhoneControl, "PhoneCallHeaderUtil::SetCallHeaderTexts - CNAP(%d), AuxLine(%d)", cnap, auxLine );

    if ( !cli && !cnap && numberType != EPEPrivateNumber && numberType != EPEUnknownNumber )

        {

        if ( auxLine )

            {

            if ( aWaitingCall )

                {

                labelId = EPhoneIncomingLine2WaitingText; // waiting, line 2

                }

            else

                {

                labelId = EPhoneIncomingLine2Text; // on line 2

                }

            }

        // If CLIR, but also network limitation(e.g. EPEUnknownNumber), then second line 

        // should be empty in call bubble.

        else

            {

            labelId = KPhoneRssCommonFirst; // No second line in call bubble

            }

        }

    else  // Voice or video call with CLI or with CNAP.

        {

        if ( aWaitingCall )

            {

            if ( auxLine  )

                {

                labelId = EPhoneIncomingLine2WaitingText; // waiting, line 2

                }

            else

                {

                labelId = EPhoneCallWaitingLabel; // waiting

                }

            }

        else // Mo other calls

            {

            if ( auxLine )

                {

                labelId = EPhoneIncomingLine2CallingText; // calling, line 2

                }

            else

                {

                // If CLIR, but not network limitation, then second line 

                // (calling or video call) should be shown in call bubble.

                if ( aVideoCall )

                    {

                    labelId = EPhoneVideoCallIncoming; // video call

                    }

                else

                    {

                    labelId = EPhoneIncomingCallLabel; // calling

                    }

                }

            }

        }

    __PHONELOG1( EBasic, EPhoneControl, "PhoneCallHeaderUtil::SetCallHeaderTexts - labelId(%d)", labelId );

    LoadCallHeaderTexts( labelId, aCallHeaderData );

    }

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

// PhoneCallHeaderUtil::LabelText

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

//

const TDesC& PhoneCallHeaderUtil::LabelText( TInt aCallId )

    {

    if (iLabelText)

        {

        delete iLabelText;

        iLabelText = NULL;

        }

    switch (m_engineInfo.CallState(aCallId))

        {

        case EPEStateDisconnecting:

            {

            iLabelText = LoadResource(EPhoneInCallDisconnected);

            break;

            }

        case EPEStateHeld:

        case EPEStateHeldConference:

            {

            iLabelText = LoadResource(EPhoneCallOnHold);

            break;

            }

        case EPEStateConnectedConference:

            {

            iLabelText = LoadResource(EPhoneCLIConferenceCall);

            break;

            }

        case EPEStateRinging:

            {

            TPhoneCmdParamCallHeaderData callHeaderData;

            SetCallHeaderTexts(

                aCallId, 

                EFalse,

                IsVideoCall( aCallId ),

                &callHeaderData );           

            if (callHeaderData.LabelText().Length())

                {

                iLabelText = callHeaderData.LabelText().Alloc();

                }

            break;

            }

        default:

            break;

        }

    return iLabelText ? *iLabelText : KNullDesC();

    }

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

// PhoneCallHeaderUtil::EmergencyHeaderText

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

//

const TDesC& PhoneCallHeaderUtil::EmergencyHeaderText()

    {

    if (!iEmergencyHeaderText)

        {

        iEmergencyHeaderText = LoadResource(EPhoneEmergencyCallHeader);

        }

    return iEmergencyHeaderText ? *iEmergencyHeaderText : KNullDesC();

    }

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

// PhoneCallHeaderUtil::AttemptingEmergencyText

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

//

const TDesC& PhoneCallHeaderUtil::AttemptingEmergencyText()

    {

    if (!iAttemptingEmergencyText)

        {

        iAttemptingEmergencyText = LoadResource(EPhoneAttemptingEmergencyText);

        }

    return iAttemptingEmergencyText ? *iAttemptingEmergencyText : KNullDesC();

    }

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

// PhoneCallHeaderUtil::CallState

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

//

TInt PhoneCallHeaderUtil::CallState( TInt aCallId ) const

    {

    return m_engineInfo.CallState(aCallId);

    }

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

// PhoneCallHeaderUtil::SetCliParamatersL

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

// 

void PhoneCallHeaderUtil::SetCliParamaters(

        const TInt aCallId, 

        TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetCliParamatersL( ) ");

    // Set call header number type

    aCallHeaderData->SetNumberType( m_engineInfo.RemotePhoneNumberType( aCallId ) );

    if ( ( m_engineInfo.RemotePhoneNumber( aCallId ).Length() ) && 

         ( !ContactInfoAvailable( aCallId ) ) )

        {

        // Set phonenumber/URI as the CLI text for the call header      

       aCallHeaderData->SetCLIText( m_engineInfo.RemotePhoneNumber( aCallId ),

                 TPhoneCmdParamCallHeaderData::ELeft );

        // No contact name, use phonenumber when available.

        aCallHeaderData->SetParticipantListCLI(

                TPhoneCmdParamCallHeaderData::EPhoneParticipantCNAPText );

        }

    else

        {

        TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection cnapClippingDirection = TPhoneCmdParamCallHeaderData::ERight;

        TBuf<KCntMaxTextFieldLength> remoteInfoText( KNullDesC );

        TBool secondaryCli = GetRemoteInfoData( aCallId, remoteInfoText );

        cnapClippingDirection = TPhoneCmdParamCallHeaderData::ELeft;

        aCallHeaderData->SetCLIText( remoteInfoText,  TPhoneCmdParamCallHeaderData::ERight );

        if (secondaryCli)

            {

            aCallHeaderData->SetCNAPText( m_engineInfo.RemotePhoneNumber( aCallId ), 

                cnapClippingDirection );

            }

        }

    SetCallerImage( aCallId, aCallHeaderData );

    // Set the Caller text

    if ( m_engineInfo.CallerText( aCallId ).Length() > 0 )

        {

        aCallHeaderData->SetCallerText( m_engineInfo.CallerText( aCallId ) );

        }

    }

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

// PhoneCallHeaderUtil::SetCallerImage

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

//     

void PhoneCallHeaderUtil::SetCallerImage( 

        const TInt aCallId, 

        TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetCallerImage( ) ");

    // Set the call header picture data if it is available

    if ( ( m_engineInfo.CallerImage( aCallId ).Length() > 0 )  && 

         ( BaflUtils::FileExists( CCoeEnv::Static()->FsSession(), 

                 m_engineInfo.CallerImage( aCallId ) ) ) )

        {

        aCallHeaderData->SetPicture( m_engineInfo.CallerImage( aCallId ) );

        }

    else

        {

        // Set the thumbnail picture data if it is available

        aCallHeaderData->SetHasThumbnail( m_engineInfo.HasCallerThumbnail( aCallId ) );

        CFbsBitmap* picture = m_engineInfo.CallerThumbnail( aCallId );

        if ( picture )

            {

            aCallHeaderData->SetThumbnail( picture );

            }

        }

    }

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

//  PhoneCallHeaderUtil::SetBasicCallHeaderParamsL

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

//

void PhoneCallHeaderUtil::SetBasicCallHeaderParams(

        const TInt aCallId, 

        TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetBasicCallHeaderParamsL( ) ");

    // Set call header call state

    aCallHeaderData->SetCallState( 

            m_engineInfo.CallState( aCallId ) );

    // Set call header type            

    aCallHeaderData->SetCallType( GetCallType( aCallId, aCallHeaderData ) );

    // Set call header voice privacy status

    aCallHeaderData->SetCiphering( 

            m_engineInfo.IsSecureCall( aCallId ) );

    aCallHeaderData->SetCipheringIndicatorAllowed( 

            m_engineInfo.SecureSpecified() );

    //see service provider settings API

    aCallHeaderData->SetServiceId(

            m_engineInfo.ServiceId( aCallId ) );

    // Set contact link, see virtual phonebook API

    aCallHeaderData->SetContactLink(

            m_engineInfo.ContactLink( aCallId ) );

    // Set remote phone number

    aCallHeaderData->SetRemotePhoneNumber(

            m_engineInfo.RemotePhoneNumber( aCallId ) );

    }

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

//  PhoneCallHeaderUtil::GetCallType

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

//

TPECallType PhoneCallHeaderUtil::GetCallType( 

        const TInt aCallId,

        TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::GetCallType( ) ");

    // Set call header type.

    TPECallType callType = 

            m_engineInfo.CallType( aCallId );

    SetCallHeaderType( callType );

    if ( m_engineInfo.CallALSLine( aCallId ) 

         == CCCECallParameters::ECCELineTypeAux )

        {

        aCallHeaderData->SetLine2( ETrue );

        }

    __PHONELOG1( EBasic, EPhoneControl, 

                "PhoneCallHeaderUtil::GetCallType() - callType: %d ", 

                callType )

    return callType;

    }

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

//  PhoneCallHeaderUtil::SetCallHeaderType

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

//

void PhoneCallHeaderUtil::SetCallHeaderType( 

    TInt aCallHeaderType )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetCallHeaderType( ) ");

    iCallHeaderType = aCallHeaderType;

    __PHONELOG1( EBasic, EPhoneControl, 

                    "PhoneCallHeaderUtil::SetCallHeaderType() - iCallHeaderType: %d ", 

                    iCallHeaderType )

    }

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

//  PhoneCallHeaderUtil::CallHeaderType

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

//

TInt PhoneCallHeaderUtil::CallHeaderType() const

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::CallHeaderType( ) ");

    __PHONELOG1( EBasic, EPhoneControl, 

                        "PhoneCallHeaderUtil::CallHeaderType() - iCallHeaderType: %d ", 

                        iCallHeaderType )

    return iCallHeaderType;            

    }

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

//  PhoneCallHeaderUtil::ContactInfoAvailable

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

//

TBool PhoneCallHeaderUtil::ContactInfoAvailable( const TInt aCallId ) const

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::ContactInfoAvailable( ) ");

    TBool contactAvailable = EFalse;

    if ( ( m_engineInfo.RemoteName( aCallId ).Length() ) || 

         ( m_engineInfo.RemoteCompanyName( aCallId ).Length() ) )

        {

        contactAvailable = ETrue;

        }

    return contactAvailable;

    }

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

// PhoneCallHeaderUtil::SetCliAndCnapParamatersL

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

// 

void PhoneCallHeaderUtil::SetCliAndCnapParamaters(

        const TInt aCallId, 

        TPhoneCmdParamCallHeaderData* aCallHeaderData )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::SetCliAndCnapParamatersL( ) ");

    TBuf<KCntMaxTextFieldLength> cnapText( KNullDesC );

    // Set call header number type

    aCallHeaderData->SetNumberType( m_engineInfo.RemotePhoneNumberType( aCallId ) );

    const MPEClientInformation& info = 

            m_engineInfo.CallClientInformation( aCallId );

    if ( ( m_engineInfo.RemotePhoneNumber( aCallId ).Length() ) && 

         ( !ContactInfoAvailable( aCallId ) ) && 

         ( !info.ShowNumber() ) )

        {

        // No contact info data available; use the phone number

        aCallHeaderData->SetCLIText(

                m_engineInfo.RemotePhoneNumber( aCallId ),

                TPhoneCmdParamCallHeaderData::ELeft);

        // No contact name, use phonenumber when available.

        aCallHeaderData->SetParticipantListCLI( 

                TPhoneCmdParamCallHeaderData::EPhoneParticipantCNAPText );

        }

    else

        {

        TBuf<KCntMaxTextFieldLength> remoteInfoText( KNullDesC );

        GetRemoteInfoData( aCallId, remoteInfoText );

        aCallHeaderData->SetCLIText( remoteInfoText, TPhoneCmdParamCallHeaderData::ERight );

        }

    // Fetch CNAP text and clipping direction

    TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection cnapClippingDirection;

    GetCNAPText( aCallId, cnapText, cnapClippingDirection );

    // Set CNAP data 

    aCallHeaderData->SetCNAPText( cnapText, cnapClippingDirection );

    // Set caller image 

    SetCallerImage( aCallId, aCallHeaderData );

    // Set the Caller text

    if ( m_engineInfo.CallerText( aCallId ).Length() > 0 )

        {

        aCallHeaderData->SetCallerText( m_engineInfo.CallerText( aCallId ) );

        }        

    // Set the call header CNAP data ( Contains possible CNAP name or received skype identification ).

    if ( IsFeatureSupported( KTelephonyLVFlagUUS, aCallId ) )

        {

        aCallHeaderData->SetCNAPText( m_engineInfo.RemotePartyName( aCallId ), 

                TPhoneCmdParamCallHeaderData::ERight );

        }

    }

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

//  PhoneCallHeaderUtil::GetCNAPText

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

//

void PhoneCallHeaderUtil::GetCNAPText( 

    const TInt aCallId,

       TDes& aData, 

       TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection& aDirection ) const

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::GetCNAPText( ) ");

    // Set clipping direction  

    aDirection = TPhoneCmdParamCallHeaderData::ERight;

    // If it's not a private number show further info

    if ( m_engineInfo.RemotePhoneNumberType( aCallId ) != 

        EPEPrivateNumber )

        {

        if ( ( m_engineInfo.RemoteName( aCallId ).Length() ||

               m_engineInfo.RemotePartyName( aCallId ).Length() || 

               m_engineInfo.RemoteCompanyName( aCallId ).Length() ) &&

               m_engineInfo.RemotePhoneNumber( aCallId ).Length() )

            {

            // Use the phone number for the CNAP display

            aData.Copy( m_engineInfo.RemotePhoneNumber( aCallId ) );

            // Clipping direction for non-private number

            aDirection = TPhoneCmdParamCallHeaderData::ELeft;

            }

        }

    }

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

//  PhoneCallHeaderUtil::IsFeatureSupported

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

//

TBool PhoneCallHeaderUtil::IsFeatureSupported( 

        const TInt aFeatureKey, 

        const TInt aCallId ) const

    {

    __LOGMETHODSTARTEND(EPhoneControl, "PhoneCallHeaderUtil::IsFeatureSupported( ) ");

    TBool featureSupport(EFalse);

    switch( aFeatureKey )

        {

        case KTelephonyLVFlagUUS:

            {

            if( ( CPhoneCenRepProxy::Instance()->IsTelephonyFeatureSupported( aFeatureKey ) ) &&

                ( m_engineInfo.RemotePartyName( aCallId ).Length() ) )

                {

                featureSupport = ETrue;

                }