/*

* Copyright (c) 2005-2008 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 CPhoneSingleCall class.

*

*/

// INCLUDES

#include <eikmenub.h> 

#include <eikenv.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <pevirtualengine.h>

#include <mpeengineinfo.h>

#include <cpephonemodelif.h>

#include <connect/sbdefs.h>

#include <videotelcontrolmediatorapi.h>

#include <MediatorDomainUIDs.h>

#include <telephonyvariant.hrh>

#include "cphonesinglecall.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamcallheaderdata.h"

#include "mphonestatemachine.h"

#include "tphonecmdparaminteger.h"

#include "phoneviewcommanddefinitions.h"

#include "phoneui.hrh"

#include "cphonemainresourceresolver.h"

#include "phonerssbase.h"

#include "phonestatedefinitionsgsm.h"

#include "tphonecmdparamglobalnote.h"

#include "tphonecmdparamcallstatedata.h"

#include "phonelogger.h"

#include "cphonepubsubproxy.h"

#include "cphonemediatorfactory.h"

#include "cphonemediatorsender.h"

#include "cphoneswitchtovideoorvoicecommand.h"

#include "mphonestorage.h"

#include "cphonecenrepproxy.h"

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

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

// might leave.

//

EXPORT_C CPhoneSingleCall::CPhoneSingleCall( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization ) : 

    CPhoneGsmInCall( aStateMachine, aViewCommandHandle, aPhoneCustomization )

    {

    }

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

// CPhoneSingleCall::~CPhoneSingleCall()

// Destructor

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

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

//

EXPORT_C CPhoneSingleCall::~CPhoneSingleCall()

    {

    }

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

// CPhoneSingleCall::ConstructL()

// Constructor

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

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

//

EXPORT_C void CPhoneSingleCall::ConstructL()

    {

    CPhoneGsmInCall::ConstructL();

    // Re-enable global notes

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    TPhoneCmdParamBoolean holdFlag;

    holdFlag.SetBoolean( EFalse );

    // Fetch active call's id from view    

    TPhoneCmdParamCallStateData callStateData;

    callStateData.SetCallState( EPEStateConnected );

    iViewCommandHandle->HandleCommandL(

        EPhoneViewGetCallIdByState, &callStateData );

    if( callStateData.CallId() == KErrNotFound )

        {

        holdFlag.SetBoolean( ETrue );

        // No connected call, find the hold call

        callStateData.SetCallState( EPEStateHeld );                    

        iViewCommandHandle->HandleCommandL(

            EPhoneViewGetCallIdByState, &callStateData );

        if ( callStateData.CallId() == KErrNotFound ) 

            {

            // No hold call, find the disconnected call

            callStateData.SetCallState( EPEStateDisconnecting );                    

            iViewCommandHandle->HandleCommandL(

            EPhoneViewGetCallIdByState, &callStateData );    

            }

        }

    iCallId = callStateData.CallId();

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

    // Update phone number availability for menu use

    PhoneNumberAvailableInPhoneEngineL( callStateData.CallId() );

    }

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

// CPhoneSingleCall::NewL()

// Constructor

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

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

//

CPhoneSingleCall* CPhoneSingleCall::NewL( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization )

    {

    CPhoneSingleCall* self = new( ELeave ) CPhoneSingleCall( 

        aStateMachine, aViewCommandHandle, aPhoneCustomization );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneSingleCall::HandleKeyMessageL

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

//

EXPORT_C void CPhoneSingleCall::HandleKeyMessageL( 

    TPhoneKeyEventMessages aMessage,

    TKeyCode aCode )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneSingleCall::HandleKeyMessageL()");

    switch ( aCode )

        {

        // send-key

        case EKeyYes:

            if( IsNumberEntryUsedL() )

                {

                if ( IsVideoCallActiveL() )

                    {

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

                    TPtr ptr( phoneNumber->Des() );

                    TPhoneCmdParamString stringParam;

                    stringParam.SetString( &ptr );

                    iViewCommandHandle->ExecuteCommand(

                        EPhoneViewGetNumberFromEntry,

                        &stringParam );

                    iStateMachine->PhoneEngineInfo()->SetPhoneNumber( ptr ) ;

                    if (  iStateMachine->PhoneEngineInfo()->PhoneNumberIsServiceCode() ||

                          phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )

                        {  

                        // Send a manual control sequence by providing number 

                        // information with dial command

                        CallFromNumberEntryL();

                        }

                    else

                        {

                        iStateMachine->SendPhoneEngineMessage( 

                            MPEPhoneModel::EPEMessageCheckEmergencyNumber );

                        }

                    CleanupStack::PopAndDestroy( phoneNumber ); 

                    }

                else

                    {

                    // Provide number information with dial command

                    CallFromNumberEntryL();

                    }

                }

            else

                {

                ToggleHoldL();                    

                }

            break;

        default:

            // do base operation

            CPhoneGsmInCall::HandleKeyMessageL( aMessage, aCode );

            break;

        }

    }

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

// CPhoneSingleCall::HandlePhoneEngineMessageL

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

//

EXPORT_C void CPhoneSingleCall::HandlePhoneEngineMessageL( 

    const TInt aMessage, 

    TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneSingleCall::HandlePhoneEngineMessageL()");

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageHeld:

            HandleHeldL( aCallId );

            break;

        case MEngineMonitor::EPEMessageConnected:

            HandleConnectedL( aCallId );

            break;

        case MEngineMonitor::EPEMessageIncoming:

            HandleIncomingL( aCallId );

            break;

        case MEngineMonitor::EPEMessageDialing:

            HandleDiallingL( aCallId );

            break;

        /* Flow through */ 

        case MEngineMonitor::EPEMessageRemoteTerminated:  

        case MEngineMonitor::EPEMessageDisconnecting:

            iViewCommandHandle->ExecuteCommandL( EPhoneViewHideNaviPaneAudioVolume );

            CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        case MEngineMonitor::EPEMessageInValidEmergencyNumber:

            break;

        case MEngineMonitor::EPEMessageValidEmergencyNumber:

            DialVoiceCallL();

            break;

        default:

            CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        }

    }

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

// CPhoneSingleCall::HandleCommandL

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

//

EXPORT_C TBool CPhoneSingleCall::HandleCommandL( TInt aCommand )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneSingleCall::HandleCommandL()");

    TBool commandStatus = ETrue;

    switch( aCommand )

        {

        /* Flow through */           

        case EPhoneInCallCmdHold:

        case EPhoneInCallCmdUnhold:

            ToggleHoldL();

            break;

        case EPhoneInCallCmdNewCall:

            LaunchNewCallQueryL();

            break;

        case EPhoneInCallCmdNewCallCall:

            CallFromNewCallQueryL();

            break;

        case EPhoneInCallCmdSwitchToVideo:

            SwitchToVideoL();

            break;

        case EPhoneInCallCmdSwitchToVoice:

            SwitchToVoiceL();

            break;

        case EPhoneCmdYesSwitchToVideo:

            // Set current call id

            iStateMachine->SetCallId( iCallId );

            iStateMachine->SendPhoneEngineMessage(

                CPEPhoneModelIF::EPEMessageSwitchToVideoOrVoice );

            break;

        /* Flow through */ 

        case EPhoneCmdNoSwitchToVideo:

        case EPhoneCmdNoSwitchToVoice:

            // Sets touch buttons to correct status if 'No' command has occured.    

            iViewCommandHandle->ExecuteCommand( EPhoneResetTouchButtons );    

            break;        

        case EPhoneCmdYesSwitchToVoice:

            // Set current call id

            iStateMachine->SetCallId( iCallId );

                        if( IsVideoCall( iCallId ) )

                        {

                           // Video call can be released only after we get response to VT Shutdown Command

                           CPhoneMediatorFactory::Instance()->Sender()->IssueCommand( KMediatorVideoTelephonyDomain,

                                                                                      KCatPhoneToVideotelCommands, 

                                                                                      EVtCmdReleaseDataport,

                                                                                      TVersion( KPhoneToVideotelCmdVersionMajor,

                                                                                            KPhoneToVideotelCmdVersionMinor, 

                                                                                            KPhoneToVideotelCmdVersionBuild ),

                                                                                      KNullDesC8,

                                                                                      CPhoneSwitchToVideoOrVoiceCommand::NewL( *iStateMachine ) );

                        }

                        else

                        {

                          iStateMachine->SendPhoneEngineMessage(

                              CPEPhoneModelIF::EPEMessageSwitchToVideoOrVoice );                    

                        }

            break;

        case EPhoneVideoSharing:

        case EPhoneVideoSharingOpt2:

        case EPhoneVideoSharingOpt3:

            {

            TPhoneCmdParamInteger command;

            command.SetInteger( aCommand );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewSendAiwCommand, 

                &command );                

            }

            break;           

        default:

            commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

            break;

        }

    return commandStatus;

    }

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

// CPhoneSingleCall::OpenMenuBarL

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

//

EXPORT_C void CPhoneSingleCall::OpenMenuBarL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneSingleCall::OpenMenuBarL()");

    if ( IsVideoCall ( iCallId ))

        {

        OpenVideoCallMenuBarL();

        }

    else

        {

        CPhoneGsmInCall::OpenMenuBarL();            

        }

    }

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

// CPhoneSingleCall::CallId

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

//

EXPORT_C TInt CPhoneSingleCall::CallId() const

    {

    return iCallId;

    }

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

// CPhoneSingleCall::OpenVideoCallMenuBarL

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

//

void CPhoneSingleCall::OpenVideoCallMenuBarL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneSingleCall::OpenVideoCallMenuBarL()");

    if( FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) )

        {

        TInt resourceId;

        if ( IsNumberEntryUsedL() )

            {

            resourceId = EPhoneVideoCallMenubarWithNumberEntry;

            }

        else

            {

            resourceId = EPhoneVideoCallMenubar;

            }

        TPhoneCmdParamInteger integerParam;

        integerParam.SetInteger( 

            CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( resourceId ) );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarOpen, 

            &integerParam );

        }                    

    }

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

// CPhoneSingleCall::HandleHeldL

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

//

void CPhoneSingleCall::HandleHeldL( TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneSingleCall::HandleHeldL()");

    TPhoneCmdParamCallHeaderData callHeaderParam;

    callHeaderParam.SetCallState( EPEStateHeld );

    TInt callLabelId;

    TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );

    callLabelId = CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( EPhoneCallOnHold );

    StringLoader::Load( 

        labelText, 

        callLabelId, 

        CCoeEnv::Static() );        

    callHeaderParam.SetLabelText( labelText );

    iViewCommandHandle->ExecuteCommandL( 

        EPhoneViewUpdateBubble, aCallId, &callHeaderParam );

    // Set Hold flag to view

    TPhoneCmdParamBoolean holdFlag;

    holdFlag.SetBoolean( ETrue );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

    if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

        { 

        HandleHoldNoteL( aCallId , ETrue );

        }

    UpdateInCallCbaL();

    SetTouchPaneButtons( EPhoneIncallHeldButtons );

    }

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

// CPhoneSingleCall::HandleConnectedL

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

//

void CPhoneSingleCall::HandleConnectedL( TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneSingleCall::HandleConnectedL()");

    // Show bubble

    TPhoneCmdParamCallHeaderData callHeaderParam;

    callHeaderParam.SetCallState( EPEStateConnected );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId, 

        &callHeaderParam );

    // Get initial hold flag from view. 

    TPhoneCmdParamBoolean holdFlag;

    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetHoldFlag, &holdFlag );

    if ( holdFlag.Boolean() )

        {

        // Update hold flag to view

        holdFlag.SetBoolean( EFalse );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

        if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

            {

            HandleHoldNoteL( aCallId , EFalse );

            }

        }

    UpdateInCallCbaL();  

    SetTouchPaneButtons( EPhoneIncallButtons );

    }

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

// CPhoneSingleCall::ToggleHold

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

//

void CPhoneSingleCall::ToggleHoldL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneSingleCall::ToggleHoldL()");

    TPECallControlCaps callControlCaps =

        iStateMachine->PhoneEngineInfo()->CallControlCaps( iCallId );

    if ( callControlCaps & MCCECallObserver::ECCECapsHold  )

        {

        iStateMachine->SetCallId( iCallId );         

        iStateMachine->SendPhoneEngineMessage( 

            CPEPhoneModelIF::EPEMessageHold );    

        }

    else if ( callControlCaps & MCCECallObserver::ECCECapsResume )

        {

        iStateMachine->SetCallId( iCallId );         

        iStateMachine->SendPhoneEngineMessage( 

            CPEPhoneModelIF::EPEMessageResume );    

        }

    else

        {

        }

    }

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

// CPhoneSingleCall::HandleIncomingL

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

//

void CPhoneSingleCall::HandleIncomingL( TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneSingleCall::HandleIncomingL()");

    BeginUiUpdateLC();

    TPhoneCmdParamBoolean dialerParam;

    dialerParam.SetBoolean( ETrue );

    // Get allow waiting call header param value.

    AllowShowingOfWaitingCallHeaderL( dialerParam );    

    // Display incoming call

    DisplayIncomingCallL( aCallId, dialerParam );

    // Show incoming call buttons

    SetTouchPaneButtons( EPhoneWaitingCallButtons ); 

    if( FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke ) 

            && !CPhoneCenRepProxy::Instance()->

            IsTelephonyFeatureSupported( KTelephonyLVFlagAllowUnlockOnIncoming ) 

            && ( IsKeyLockOn() || IsAutoLockOn() ) )