/*

* Copyright (c) 2008-2009 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: Implementation of CPhoneCustomizationVoip class.

*

*/

// INCLUDES

#include <eikmenup.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <mpeengineinfo.h>

#include <bmbubblemanager.h>

#include <phoneui.rsg>

#include <avkon.rsg>

#include <phoneuivoip.rsg>

#include <StringLoader.h>

#include <featmgr.h>

#include "cphonecustomizationvoip.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamstring.h"

#include "cphonemainresourceresolver.h"

#include "mphonestatemachine.h"

#include "cphonelogger.h"

#include "cphonecenrepproxy.h"

#include "phoneui.pan"

#include "mphoneviewcommandhandle.h"

#include "tphonecmdparamdynmenu.h"

#include "phoneappvoipcommands.hrh"

#include "phonerssvoip.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparamquery.h"

#include "tphonecmdparamcallheaderdata.h"

#include "cphoneextensionhandler.h"

#include "cphonestate.h"

#include "tphonecmdparamglobalnote.h"

#include "cphonestatemachinevoip.h"

#include "cphonevoiperrormessageshandler.h"

#include "cphoneviewcustomizationvoip.h"

#include "cphonestateutilsvoip.h"

#include "cphoneunattendedtransfercmdhandler.h"

#include "tphonecmdparampointer.h"

#include "cphonenewcallcmdhandler.h"

#include "cphonevcchandler.h"

#include "cphonecallforwardqueryhandler.h"

#include "cphonekeys.h"

// CONSTANTS

const TInt KMaxLengthForSIPURIFirstLine = 15;

const TInt KMaxLengthForSIPURITwoLines = 30;

const TInt KMaxLengthForSIPURI = 256;

_LIT( KVoipAt, "@" );

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CPhoneCustomizationVoip::CPhoneCustomizationVoip( 

    MPhoneStateMachine& aStateMachine,

    MPhoneViewCommandHandle& aViewCommandHandle ) : 

    iCoeEnv( *CCoeEnv::Static() ),

    iStateMachine( aStateMachine ),

    iViewCommandHandle( aViewCommandHandle )

    {

    }

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

// CPhoneCustomizationVoip::~CPhoneCustomizationVoip()

// Destructor

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

//

CPhoneCustomizationVoip::~CPhoneCustomizationVoip()

    {

    delete iCallForwardHandler;

    delete iExtensionHandler;

    delete iPhoneViewCustomization;

    delete iTransferCmdHandler;

    delete iNewCallCmdHandler;

	delete iVccHandler;

    }

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

// CPhoneCustomizationVoip::ConstructL()

// Constructor

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

//

void CPhoneCustomizationVoip::ConstructL()

    {

    // Set view customization

    iPhoneViewCustomization = CPhoneViewCustomizationVoip::NewL( *this );

    TPhoneCmdParamPointer pointerParam;

    pointerParam.SetPointer( 

        static_cast<MPhoneViewCustomization*>( iPhoneViewCustomization ) );

    iViewCommandHandle.ExecuteCommand( EPhoneViewSetViewCustomization, 

        &pointerParam );

    // Set touch button customization

    pointerParam.SetPointer( 

        static_cast<MPhoneButtonCustomization*>( this ) );

    iViewCommandHandle.ExecuteCommand( EPhoneViewSetButtonCustomization, 

        &pointerParam );

    // Set phone customization

    pointerParam.SetPointer( static_cast<MPhoneCustomization*>( this ) );

    iViewCommandHandle.ExecuteCommand( EPhoneViewSetPhoneCustomization, 

        &pointerParam );

    iExtensionHandler = CPhoneExtensionHandler::NewL();

    iTransferCmdHandler = CPhoneUnattendedTransferCmdHandler::NewL( 

        iStateMachine, iViewCommandHandle );

    iNewCallCmdHandler = CPhoneNewCallCmdHandler::NewL( 

        iStateMachine, iViewCommandHandle );

    if ( FeatureManager::FeatureSupported( KFeatureIdFfVoiceCallContinuity ) )

        {

        iVccHandler = CPhoneVccHandler::NewL( iStateMachine, iViewCommandHandle );

        }

    iCallForwardHandler = CPhoneCallForwardQueryHandler::NewL( 

        iStateMachine, iViewCommandHandle );

    }

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

// CPhoneCustomizationVoip::NewL()

// Constructor

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

//

CPhoneCustomizationVoip* CPhoneCustomizationVoip::NewL( 

    MPhoneStateMachine& aStateMachine,

    MPhoneViewCommandHandle& aViewCommandHandle )

    {

    CPhoneCustomizationVoip* self = new (ELeave) CPhoneCustomizationVoip( 

        aStateMachine,

        aViewCommandHandle );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::CustomizeMenuBarL

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

// 

void CPhoneCustomizationVoip::CustomizeMenuBarL(

        TInt aResourceId, CEikMenuBar* aMenuBar )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::CustomizeMenuBarL" );

    if ( 0 == aResourceId || !aMenuBar )

        {

        __ASSERT_DEBUG( EFalse, Panic( EPhoneCtrlParameterNotInitialized ) );

        }

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::CustomizeMenuPaneL

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

//

void CPhoneCustomizationVoip::CustomizeMenuPaneL(

    TInt aResourceId, CEikMenuPane* aMenuPane)

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

          "CPhoneCustomizationVoip::CustomizeMenuPaneL" );

    CEikMenuPane* menuPane = aMenuPane;

    RArray<TInt> menuItemArray;

    CleanupClosePushL( menuItemArray );

    // Menu items to array

    TInt menuItemCount = menuPane->NumberOfItemsInPane();

    for ( TInt i( 0 ); i < menuItemCount; i++ )

        {

        menuItemArray.Append( menuPane->MenuItemCommandId( i ) );

        }

    // Menu items to be deleted 

    for ( TInt i( 0 ); i < menuItemArray.Count(); i++ )

        {

        switch( menuItemArray[ i ] )

            {

            case EPhoneDialerCmdTouchInput:

                {

                if ( !AllowAlphaNumericMode() )

                    {

                    menuPane->DeleteMenuItem( menuItemArray[ i ] ); 

                    }

                break;

                }

            case EPhoneInCallCmdTransfer:

                {

                if ( ! IsFeatureSupported( EFeatureTransfer ) )

                    {

                    menuPane->DeleteMenuItem( menuItemArray[ i ] ); 

                    }

                break;

                }

            case EPhoneInCallCmdCreateConference:

                {

                if ( ! IsFeatureSupported( EFeatureConference ) )

                    {

                    menuPane->DeleteMenuItem( menuItemArray[ i ] ); 

                    }

                break;

                }

            case EPhoneInCallCmdNewCall:

                {

                if ( !FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) &&

                     AllowAlphaNumericMode() &&

                     R_PHONEUI_NEW_CALL_MENU_VOIP != aResourceId )

                    {

                    menuPane->DeleteMenuItem( menuItemArray[ i ] ); 

                    HBufC* string = StringLoader::LoadLC( 

                          CPhoneMainResourceResolver::Instance()->

                          ResolveResourceID( EPhoneVoIPNewCallMenuOption ) );

                    CEikMenuPaneItem::SData data;

                    data.iCascadeId=R_PHONEUI_NEW_CALL_MENU_VOIP; //r_phoneui_new_call_menu_voip

                    data.iText = *string;

                    data.iFlags=0;

                    data.iCommandId = 0;             

                    menuPane->InsertMenuItemL( data, i );

                    CleanupStack::PopAndDestroy( string ); 

                    }

                break;

                }

            default: 

                break;

            }

        }

    CleanupStack::PopAndDestroy( &menuItemArray );    

    // Added HO menu items if needed

    AddHandoverMenuItemIfNeededL( aResourceId, *aMenuPane );

    if ( iViewCommandHandle.HandleCommandL( 

            EPhoneViewGetNumberEntryIsVisibleStatus ) != 

            EPhoneViewResponseSuccess )

        {

        // Handle call menu without dialer/number entry

        TRAP_IGNORE( ModifyInCallMenuL( aResourceId, *aMenuPane ) );

        }

    else

        {

        // Handle dialer/number entry options menu modification

        ModifyNumberAcquisitionMenuL( aResourceId, *aMenuPane );

        }

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::ModifyCallHeaderTexts

// Formats and fits VoIP address and possible display name into two lines to 

// be shown on a call bubble. These two lines are placed on CLI and CNAP 

// fields of the TPhoneCmdParamCallHeaderData. In a call bubble CLI-field is 

// placed as a first line and CNAP-field is placed as a second line. 

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

//

void CPhoneCustomizationVoip::ModifyCallHeaderTexts( TInt aCallId, 

        TPhoneCmdParamCallHeaderData* aCommandParam,

        const TDesC& /*aInCallNumberText*/ ) 

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::ModifyCallHeaderTexts" );

    MPEEngineInfo& engineInfo = *iStateMachine.PhoneEngineInfo();

    if ( EPECallTypeVoIP == engineInfo.CallType( aCallId ) ) 

        {

        const TBool contactInfoAvailable = 

            engineInfo.RemoteName( aCallId ).Length() ||

            engineInfo.RemoteCompanyName( aCallId ).Length();

        if ( EPEStateRinging == aCommandParam->CallState() &&

            !contactInfoAvailable )

            {

            if ( KNullDesC() != engineInfo.RemotePartyName( aCallId ) )

                {

                // Telephone UI specification, 4.2.1 Call identification:

                // display name is used as the CLI if available.

                aCommandParam->SetCLIText( 

                    engineInfo.RemotePartyName( aCallId ), 

                    CBubbleManager::ERight );

                // use line reserved for CNAP to show SIP URI

                aCommandParam->SetCNAPText( 

                    engineInfo.RemotePhoneNumber( aCallId ),

                    CBubbleManager::ERight );

                }

            else if( KNullDesC() != engineInfo.RemotePhoneNumber( aCallId ) )

                {

                // Fit address to two rows if it doesnt fit to one

                TBuf<KMaxLengthForSIPURI> sipURI;

                TBuf<KMaxLengthForSIPURI> sipURIDomainPart;

                HandleURIFittingToCallBubble( 

                    aCommandParam->CLIText(),

                    sipURI,

                    sipURIDomainPart );

                aCommandParam->SetCLIText( sipURI, CBubbleManager::ERight );

                aCommandParam->SetCNAPText( 

                    sipURIDomainPart,

                    CBubbleManager::ERight );

                }

            else

                {

                // No address or display name specified

                // Do nothing

                }

            }

        else

            {

            // Change clipping direction

            aCommandParam->SetCLIText( 

                aCommandParam->CLIText(), 

                CBubbleManager::ERight );

            // Change clipping direction

            aCommandParam->SetCNAPText( 

                aCommandParam->CNAPText(), 

                CBubbleManager::ERight );

            }

        }

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::HandleCommandL

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

//

TBool CPhoneCustomizationVoip::HandleCommandL( TInt aCommand )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

         "CPhoneCustomizationVoip::HandleCommandL" );

    TBool handled( EFalse );

    switch( aCommand )

        {

        case EPhoneNumberAcqCmdInternetCall:

            {

            StateUtils().SelectServiceAndDialL();

            handled = ETrue;

            }

            break;

        case EPhoneInCallCmdNewInternetCall:

        case EPhoneCmdNewInternetCallOk:

        case EPhoneCmdNewInternetCallSearch:

        case EPhoneCmdNewInternetCallContactFetch: 

            {

            iNewCallCmdHandler->HandleCommandL( aCommand );

            handled = ETrue;

            }

            break;

        case EPhoneInCallCmdUnattendedTransfer:

        case EPhoneCmdTransferDialerOk:

        case EPhoneCmdTransferDialerExit:

        case EPhoneCmdTransferDialerSearch:

        case EPhoneCmdTransferDialerContactFetch:

            // intended fall-through

            iTransferCmdHandler->HandleCommandL( aCommand );

            handled = ETrue;

            break;

        case EPhoneCmdCancelServiceEnabling:

            {

            iStateMachine.SendPhoneEngineMessage( 

                MPEPhoneModel::EPEMessageDisableService );

            handled = ETrue;

            }

            break;

        case EPhoneCmdServiceEnablingTimedOut:

            {

            iStateMachine.SendPhoneEngineMessage( 

                MPEPhoneModel::EPEMessageDisableService ); 

            TUint32 serviceId = 

                iStateMachine.PhoneEngineInfo()->ServiceIdCommand();

            static_cast<CPhoneStateMachineVoIP&>( iStateMachine ).

                VoipErrorMessageHandler().ShowErrorNoteWithServiceNameL( 

                    EPhoneVoIPServiceUnavailable, serviceId );

            handled = ETrue;

            }

            break;

        case EPhoneCmdHandoverToGsm:

            iVccHandler->StartManualHandoverL( EPhoneVoIPWaitHandoverFromWlan );

            handled = ETrue;

            break;

        case EPhoneCmdHandoverToWlan:

            iVccHandler->StartManualHandoverL( EPhoneVoIPWaitHandoverFromGsm );

            handled = ETrue;

            break;

        default:

            {

            RArray<CTelMenuExtension::TCallInfo> array;

            CleanupClosePushL( array );

            GetActiveCallArrayL( array );

            // Let extensions handle custom commands

            TRAP_IGNORE( handled = iExtensionHandler->HandleCommandL( 

                    ServiceIdForActivestCallL( array ),

                    aCommand ) );

            CleanupStack::PopAndDestroy( &array );

            }

            break;

        }

    return handled;

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::AllowAlphaNumericMode

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

//

TBool CPhoneCustomizationVoip::AllowAlphaNumericMode()

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::AllowAlphaNumericMode" );

    TBool alphaModeSupported( EFalse );

    TRAP_IGNORE( alphaModeSupported = VoIPSupportedL() );

    return alphaModeSupported;

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::CustomizeSoftKeys

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

//

TInt CPhoneCustomizationVoip::CustomizeSoftKeys()

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::CustomizeSoftKeys" );

    return CPhoneMainResourceResolver::Instance()->

        ResolveResourceID( EPhoneVoIPNumberAcqInternetSoftkey );

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::CustomizeCallHeaderText

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

//

TInt CPhoneCustomizationVoip::CustomizeCallHeaderText()

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::CustomizeCallHeaderText" );

    return EPhoneVoIPPrivateAddress;

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::CustomizeBusyNoteText

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

//

TInt CPhoneCustomizationVoip::CustomizeBusyNoteText()

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::CustomizeBusyNoteText" );

    TInt resource( EPhoneNumberBusy );

    const TPECallType callType =

        iStateMachine.PhoneEngineInfo()->CallTypeCommand();

    if ( callType == EPECallTypeVoIP )

        {

        resource = EPhoneVoIPNumberBusy;

        }

    return resource;

    }

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

// From class MPhoneCustomization.

// CPhoneCustomizationVoip::HandleCallFromNumberEntryL

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

//

TBool CPhoneCustomizationVoip::HandleCallFromNumberEntryL()

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneCustomizationVoip::HandleCallFromNumberEntryL" );

    TBool handled = EFalse;