/*

* Copyright (c) 2005-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: Implementation of CPhoneStateInCall class.

*

*/

// INCLUDES

#include <featmgr.h>

#include <StringLoader.h>

#include <PSVariables.h>

#include <hwrmdomainpskeys.h>

#include <UikonInternalPSKeys.h>

#include <mpeengineinfo.h>

#include <videotelcontrolmediatorapi.h>

#include <MediatorDomainUIDs.h>

#include <bldvariant.hrh>

#include <coreapplicationuisdomainpskeys.h>

#include "cphonestateincall.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamnote.h"

#include "tphonecmdparamquery.h"

#include "tphonecmdparamsingleitemfetch.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparamsfidata.h"

#include "mphonestatemachine.h"

#include "mphonesecuritymodeobserver.h"

#include "phonestatedefinitions.h"

#include "phoneviewcommanddefinitions.h"

#include "phoneui.hrh"

#include "phonerssbase.h"

#include "cphonemainresourceresolver.h"

#include "phonelogger.h"

#include "phoneui.pan"

#include "cphonepubsubproxy.h"

#include "cphonedtmfwaitchartimer.h"

#include "tphonecmdparamcallheaderdata.h"

#include "cphonemediatorfactory.h"

#include "cphonemediatorsender.h"

#include "cphoneterminateallconnectionscommand.h"

#include "mphonecustomization.h"

#include "easydialingcommands.hrh"

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

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

// might leave.

//

EXPORT_C CPhoneStateInCall::CPhoneStateInCall( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aCustomization ) : 

    CPhoneState( aStateMachine, aViewCommandHandle, aCustomization ),

    iDtmfWaitCharTimer( NULL )

    {

    }

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

// CPhoneStateInCall::~CPhoneStateInCall()

// Destructor

// (other items were commented in a header).

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

//

EXPORT_C CPhoneStateInCall::~CPhoneStateInCall()

    {

    delete iDtmfWaitCharTimer;            

    }

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

// CPhoneStateInCall::ConstructL()

// Constructor

// (other items were commented in a header).

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

//

EXPORT_C void CPhoneStateInCall::ConstructL()

    {

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

        Panic( EPhoneCtrlInvariant ) );

    CPhoneState::BaseConstructL();

    // Enable the volume display

    iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNaviPaneAudioVolume );

    }

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

// CPhoneStateInCall::NewL()

// Constructor

// (other items were commented in a header).

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

//

CPhoneStateInCall* CPhoneStateInCall::NewL( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization )

    {

    CPhoneStateInCall* self = new (ELeave) CPhoneStateInCall( 

        aStateMachine, aViewCommandHandle, aPhoneCustomization );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneStateInCall::HandleKeyMessageL

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

//

EXPORT_C void CPhoneStateInCall::HandleKeyMessageL( 

    TPhoneKeyEventMessages aMessage,

    TKeyCode aCode )

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleKeyMessageL()" ); 

    switch ( aCode )

        {

        // end-key

        case EKeyNo:

            HandleEndKeyPressL( aMessage );

            break;

        // Voice key

        case EKeyDevice6:

            HandleVoiceKeyPressL( aMessage ); 

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT

        case EKeyEnter:

                {

                SendDtmfL();    

                }

            else if ( IsNumberEntryVisibleL() )

                {

                if ( IsDialingExtensionInFocusL() )

                    {

                    iViewCommandHandle->HandleCommandL(

                                       EEasyDialingEnterKeyAction );

                    }

                else

                    {

                    if ( neLength > 0 )

                       {

                       HandleCommandL( EPhoneNumberAcqCmdSendCommand );

                       }

                    }      

                }

            break;

#endif            

        default:

            break;

        }

    }

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

// CPhoneStateInCall::HandleNumberEntryClearedL()

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

//

EXPORT_C void CPhoneStateInCall::HandleNumberEntryClearedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleNumberEntryClearedL()" );

    // Update single call CBA when number entry is cleared

     UpdateInCallCbaL();

    }

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

// CPhoneStateInCall::HandlePhoneEngineMessageL

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

//

EXPORT_C void CPhoneStateInCall::HandlePhoneEngineMessageL( 

    const TInt aMessage, 

    TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandlePhoneEngineMessageL()" );

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageIdle:

            HandleIdleL( aCallId );

            // Forward idle message to phone customization 

            CPhoneState::ForwardPEMessageToPhoneCustomizationL( aMessage, aCallId );

            break;

        case MEngineMonitor::EPEMessageAudioMuteChanged:

            HandleAudioMuteChangedL();

            break;

        case MEngineMonitor::EPEMessageAudioOutputChanged:

            HandleAudioOutputChangedL();

            break;

        case MEngineMonitor::EPEMessageSendingDTMF:

        case MEngineMonitor::EPEMessageContinuingDTMFSending:

            HandleSendingDTMFL();

            break;

        case MEngineMonitor::EPEMessageStoppedDTMF:

            HandleStoppedDTMFL();

            break;

        case MEngineMonitor::EPEMessageSentDTMF:

        case MEngineMonitor::EPEMessageDTMFSendingAborted:

            CancelDTMFSendingL();

            break;

        case MEngineMonitor::EPEMessagePromptSpeedDial:

            HandleDTMFPromptSpeedDialL();

            break;

        case MEngineMonitor::EPEMessageSpeedDialNotAssigned:

            CPhoneState::SendGlobalErrorNoteL( 

                EPhoneDtmfSpeedDialNotAssigned );

            break;

        case MEngineMonitor::EPEMessageInvalidSpeedDial:

            CPhoneState::SendGlobalErrorNoteL( EPhoneDtmfInvalidSpeedDial );

            break;

        case MEngineMonitor::EPEMessageAudioVolumeChanged:

            HandleAudioVolumeChangedL();

            break;

        case MEngineMonitor::EPEMessageDisconnecting:

            CancelDTMFSendingL();

            if ( !CPhoneState::IsAnyConnectedCalls() )

                {

                CloseDtmfQueryL();

                }            

            CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

            break; 

        case MEngineMonitor::EPEMessageInValidEmergencyNumber:

            SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed );

            break;

        case MEngineMonitor::EPEMessageValidEmergencyNumber:

            DialVoiceCallL();

            break;    

        case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

            // If there is a waiting call then update header and label

            // else forward message to CPhoneState.

            if ( IsWaitingCallL( aCallId ) )

                {

                // Update remote info data and label.

                UpdateRemoteInfoDataAndLabelL( aCallId, UpdateCallHeaderInfoL( aCallId ) );

                }

            else

                {

                CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

                }

            break;

        default:

            CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        }

    }

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

// CPhoneStateInCall::UpdateRemoteInfoDataAndLabelL

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

//

void CPhoneStateInCall::UpdateRemoteInfoDataAndLabelL( 

        TInt aCallId, 

        TPhoneCmdParamCallHeaderData aCallHeaderParam )

    {

    __LOGMETHODSTARTEND(EPhoneControl,

            "CPhoneStateInCall::UpdateRemoteInfoDataAndLabelL ()" );

    // Update the remote info data in the call header

    iViewCommandHandle->ExecuteCommandL( 

        EPhoneViewUpdateCallHeaderRemoteInfoDataAndLabel, 

        aCallId,

        &aCallHeaderParam );

    }

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

// CPhoneStateInCall::HandleIdleL

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

//

EXPORT_C void CPhoneStateInCall::HandleIdleL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleIdleL()" );

    __ASSERT_DEBUG( aCallId >= 0, Panic( EPhoneCtrlParameterNotInitialized ) );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewHideToolbar );

    SetDefaultFlagsL();

    if ( IsNumberEntryUsedL() )

        {

        // Show the number entry if it exists and update cba's.

        SetNumberEntryVisibilityL( ETrue );

        // Close dtmf dialer when call is disconnected.

        if ( IsDTMFEditorVisibleL() )

            {      

            CloseDTMFEditorL();

            // Display idle screen and update CBA's

            DisplayIdleScreenL();

            }

        else if ( iOnScreenDialer && IsCustomizedDialerVisibleL() )

            {            

            CloseCustomizedDialerL();

            // Display idle screen and update CBA's

            DisplayIdleScreenL();

            } 

        }            

    else

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

        if ( !TopAppIsDisplayedL() || IsAutoLockOn() || NeedToReturnToForegroundAppL() )

            {        

            // Continue displaying current app but set up the 

            // idle screen in the background

            SetupIdleScreenInBackgroundL();

            }

        else

            {

            // Display idle screen and update CBAs

            DisplayIdleScreenL();

            }

        }

    DeleteTouchPaneButtons();

    DisplayCallTerminationNoteL();

    iStateMachine->ChangeState( EPhoneStateIdle );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewHideToolbar );

    }

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

// CPhoneStateInCall::UpdateInCallCbaL

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

//

EXPORT_C void CPhoneStateInCall::UpdateInCallCbaL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateInCall::UpdateInCallCbaL() ");

    UpdateCbaL( EPhoneCallHandlingInCallCBA );

    }

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

// CPhoneStateInCall::UpdateCbaL

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

//

EXPORT_C void CPhoneStateInCall::UpdateCbaL( TInt aResource )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateInCall::UpdateCbaL() ");

    if ( iOnScreenDialer && IsNumberEntryVisibleL() && IsDTMFEditorVisibleL() )

        {

        iCbaManager->SetCbaL( EPhoneDtmfDialerCBA );        

        }

    else if ( iOnScreenDialer && IsNumberEntryVisibleL() && IsCustomizedDialerVisibleL() )

        {

        iCbaManager->SetCbaL( CustomizedDialerCbaResourceIdL() );

        }

    else

        {

        iCbaManager->UpdateCbaL( aResource );   

        }

    }

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

// CPhoneStateInCall::HandleAudioMuteChangedL

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

//

void CPhoneStateInCall::HandleAudioMuteChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleAudioMuteChangedL()" );

    CPhoneState::HandleAudioMuteChangedL();

    // Update the single call CBA only if the number entry is not

    // used

    if ( !IsNumberEntryUsedL() )

        {

        // Go to current state implementation

        UpdateInCallCbaL();

        }

	TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();

    TPhoneCmdParamCallStateData callStateData;

    callStateData.SetCallState( EPEStateConnected );

    iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, &callStateData );

    TInt call = callStateData.CallId();

    if ( call != KErrNotFound  && iStateMachine->PhoneEngineInfo()->CallType( call ) == EPECallTypeVoIP

            && audioMute )

		{

			  TPhoneCmdParamBoolean dtmfSendFlag;

			  dtmfSendFlag.SetBoolean( ETrue );

			  iViewCommandHandle->ExecuteCommandL( EPhoneViewSetVoipCallDTMFVisibilityFlag,

																							   &dtmfSendFlag );

		}

    else

		{           

		 TPhoneCmdParamBoolean dtmfSendFlag;

		  dtmfSendFlag.SetBoolean( EFalse );

		  iViewCommandHandle->ExecuteCommandL( EPhoneViewSetVoipCallDTMFVisibilityFlag,

																						   &dtmfSendFlag );

		} 

    }

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

// CPhoneStateInCall::HandleAudioOutputChangedL

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

//

void CPhoneStateInCall::HandleAudioOutputChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleAudioOutputChangedL()" );

    // Handle the handsfree mode change

    CPhoneState::HandleAudioOutputChangedL();

    // Update the single call CBA only if the number entry is not

    // used

    if ( !IsNumberEntryVisibleL() )

        {

        // Go to current state implementation

        UpdateInCallCbaL();

        }

    }

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

// CPhoneStateInCall::HandleAudioVolumeChangedL

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

//

void CPhoneStateInCall::HandleAudioVolumeChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleAudioVolumeChangedL()" );

    // Update the volume display

    TInt audioVolume = iStateMachine->PhoneEngineInfo()->AudioVolume();

    TPhoneCmdParamInteger volumeParam;

    volumeParam.SetInteger( audioVolume );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetNaviPaneAudioVolume,

        &volumeParam );

    }

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

// CPhoneStateInCall::HandleSendingDTMFL

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

//

void CPhoneStateInCall::HandleSendingDTMFL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleSendingDTMFL()" );

    TPhoneCmdParamNote noteParam;

    noteParam.SetType( EPhoneNoteDtmfSending );

    noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->

        ResolveResourceID( EPhoneSendingDtmfWaitNote ) );

    // Show the "Sending..." Wait Note, and pre-populate it 

    // with the PhoneEngine's current DTMF String.

    // Set the text for the wait-note.

    TPEDtmfString dtmfString = iStateMachine->PhoneEngineInfo()->DtmfString();

    HBufC* noteText = StringLoader::LoadLC( 

        CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( EPhoneSendingDtmfWaitNoteText ), 

        dtmfString );

    noteParam.SetText( *noteText );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );

    CleanupStack::PopAndDestroy( noteText );

    }

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

// CPhoneStateInCall::HandleStoppedDTMFL

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

//

void CPhoneStateInCall::HandleStoppedDTMFL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleStoppedDTMFL()" );

    // Remove the Sending... note

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

    // Fetch the remaining (unparsed) portion of the DTMF String 

    // from PhoneEngine

    TPEDtmfString dtmfString = iStateMachine->PhoneEngineInfo()->DtmfString();

    if ( dtmfString.Length() )

        {

        // Show the DTMF Wait Character confirmation query

        TPhoneCmdParamQuery queryParam;

        queryParam.SetQueryType( EPhoneQueryDialog );

        queryParam.SetQueryResourceId( 

            CPhoneMainResourceResolver::Instance()->ResolveResourceID( 

                EPhoneDtmfWaitCharacterConfirmationQuery ) );

        // Append the PhoneEngine's current DTMF String to the query's prompt