/*

* Copyright (c) 2005-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 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 "cphonestateincall.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamnote.h"

#include "tphonecmdparamquery.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparamkeycapture.h"

#include "tphonecmdparamsfidata.h"

#include "mphonestatemachine.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"

// ================= 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()

    {

    if( iDtmfWaitCharTimer )

        {

        }

    }

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

// CPhoneStateInCall::ConstructL()

// Constructor

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

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

//

EXPORT_C void CPhoneStateInCall::ConstructL()

    {

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

        Panic( EPhoneCtrlInvariant ) );

    CPhoneState::BaseConstructL();

    }

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

// 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 )

        {

            HandleEndKeyPressL( aMessage );

            break;

            HandleVoiceKeyPressL( aMessage ); 

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT

        case EKeyEnter:

            if ( IsNumberEntryVisibleL() )

                {

                HandleCommandL( EPhoneCmdOptions );

                }

            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 );

            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::EPEMessageAudioVolumeChanged:

            HandleAudioVolumeChangedL();

            break;

        case MEngineMonitor::EPEMessageDisconnecting:

            CancelDTMFSendingL();

            CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

            break; 

        case MEngineMonitor::EPEMessageInValidEmergencyNumber:

            SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );

            break;

        case MEngineMonitor::EPEMessageValidEmergencyNumber:

            DialVoiceCallL();

        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 ()" );

    iViewCommandHandle->ExecuteCommandL( 

        EPhoneViewUpdateCallHeaderRemoteInfoDataAndLabel, 

        aCallId,

        &aCallHeaderParam );

    }

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

// CPhoneStateInCall::HandleIdleL

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

//

EXPORT_C void CPhoneStateInCall::HandleIdleL( TInt aCallId )

    {

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

    TBool showDialer( EFalse );

    HBufC *phoneNumber = HBufC::NewLC( KPhoneNumberEntryBufferSize );

    TPtr ptr( phoneNumber->Des() );

    TPhoneCmdParamString stringParam;

    stringParam.SetString( &ptr );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewHideToolbar );

    BeginUiUpdateLC();

    SetDefaultFlagsL();

    if ( IsNumberEntryUsedL() )

        {

        iViewCommandHandle->ExecuteCommand(

                EPhoneViewGetNumberFromEntry,

                &stringParam );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );

        showDialer = ETrue;

        }

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

        // Continue displaying current app but set up the 

        // idle screen in the background

        SetupIdleScreenInBackgroundL();

        }

    else if ( showDialer )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchLogs, &stringParam );

        }

    else 

        {

        DisplayIdleScreenL();

        }

    EndUiUpdate();

    DisplayCallTerminationNoteL();

    TPhoneCmdParamKeyCapture captureParam;

    captureParam.SetKeyCode( EKeyNo );

    iViewCommandHandle->ExecuteCommand( EPhoneViewStopCapturingKey, &captureParam );

    CleanupStack::PopAndDestroy( phoneNumber );

    iStateMachine->ChangeState( EPhoneStateIdle );

    }

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

// 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() ");

    }

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

// 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();

        }

    }

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

// CPhoneStateInCall::HandleAudioOutputChangedL

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

//

void CPhoneStateInCall::HandleAudioOutputChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleAudioOutputChangedL()" );

    CPhoneState::HandleAudioOutputChangedL();

    SetTouchPaneButtons(0);

    }

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

// CPhoneStateInCall::HandleAudioVolumeChangedL

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

//

void CPhoneStateInCall::HandleAudioVolumeChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::HandleAudioVolumeChangedL()" );

    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()" );

    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

        HBufC* queryPrompt = StringLoader::LoadLC( 

            CPhoneMainResourceResolver::Instance()->ResolveResourceID( 

                EPhoneDtmfWaitCharacterConfirmationQueryText ), 

            dtmfString );

        queryParam.SetQueryPrompt( *queryPrompt );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery, 

            &queryParam );

        CleanupStack::PopAndDestroy( queryPrompt );

        }

    else

        {

        // Stop the asynchronous sending operation the 

        // PhoneEngine may be performing.

        iStateMachine->SendPhoneEngineMessage( 

            MPEPhoneModel::EPEMessageStopDTMFSending );

        // Prompt for more characters by showing DTMF query with empty string

        HBufC* emptyString = HBufC::NewLC( KPhoneNumberEntryBufferSize );

        TPtr ptr( emptyString->Des() );

        ShowDtmfTextQueryL( 

            CPhoneMainResourceResolver::Instance()->

                ResolveResourceID( EPhoneDtmfNumberQuery ),

            CPhoneMainResourceResolver::Instance()->

                ResolveResourceID( EPhoneSendDtmfEmptyEditBoxCBA ),

            CPhoneMainResourceResolver::Instance()->

                ResolveResourceID( EPhoneSendDtmfNormalEditBoxCBA ),

            &ptr );

        CleanupStack::PopAndDestroy( emptyString );

        }

    }

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

// CPhoneStateInCall::CancelDTMFSendingL

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

//

void CPhoneStateInCall::CancelDTMFSendingL()

    {

    __LOGMETHODSTARTEND(EPhoneControl,  

        "CPhoneStateInCall::CancelDTMFSendingL()" );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveDtmfNote );

    }

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

// CPhoneStateInCall::HandleCommandL

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

//

EXPORT_C TBool CPhoneStateInCall::HandleCommandL( TInt aCommand )

    {

    __PHONELOG1 ( EBasic, EPhoneControl,

        "CPhoneStateInCall::HandleCommandL() - aCommand  = %d ", aCommand );

    TBool commandStatus = ETrue;

    switch( aCommand )

        {

        case EPhoneInCallCmdDialer:

            iViewCommandHandle->ExecuteCommandL( EPhoneViewOpenDialer );

            break;

        case EPhoneDtmfDialerCancel:

            {

            // Activate DTMF list query when cancel is pressed.

            // Forwards command to the framework 

            HandleCommandL( EPhoneInCallCmdDtmfListQuery );

            }

            break;

        case EPhoneInCallCmdEndThisActiveCall:

            CPhoneState::DisconnectCallL();

            break;

        case EPhoneCallComingCmdReject: // fall through

        case EPhoneInCallCmdReject:

            iStateMachine->SendPhoneEngineMessage( 

                MPEPhoneModel::EPEMessageReject );

            break;

        case EPhoneInCallCmdMute: // fall through

        case EPhoneInCallCmdUnmute:

            iStateMachine->PhoneEngineInfo()->SetAudioMuteCommand( 

                ( aCommand == EPhoneInCallCmdMute ) );

            iStateMachine->SendPhoneEngineMessage( 

                MPEPhoneModel::EPEMessageSetAudioMute );

            break;

        //DTMF list query - dialog   

        case EPhoneInCallCmdDtmfListQuery:

            LaunchDtmfListQueryL();

            break;

        // DTMF entry - Ok          

        case EPhoneCmdDtmfOk:

            SendDtmfL();

            break;

        // DTMF sending - Cancel

        case EPhoneInCallCmdCancelSendingDtmfString:

            // Stop the asynchronous sending operation the 

            // PhoneEngine may be performing.

            iStateMachine->SendPhoneEngineMessage(