/*

* Copyright (c) 2002-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:  This file contains the implementation of CPECallHandling class 

*                member functions.

*

*/

// INCLUDE FILES

#include    "cpecallhandling.h"

#include    "cpevideocallhandling.h"

#include    "cpesinglecall.h"

#include    "cpedtmfhandling.h"

#include    "cpesupplementaryservicesmonitor.h"

#include    "mpephonemodelinternal.h"

#include    "cpeconferencecall.h"

#include    "cpecallarrayowner.h"

#include    "mpecallhandling.h"

#include    "cpecceobserver.h"

#include    "cpesystemcallstate.h"

#include    <gsmerror.h>

#include    <mpedatastore.h>

#include    <pepanic.pan>

#include    <talogger.h>

#include    <PSVariables.h>

#include    <ctsydomainpskeys.h>

#include    <mccecall.h>

#include    <psetsaobserver.h>

#include    <cccecallparameters.h>

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ============================= LOCAL FUNCTIONS ===============================

// None

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

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

// CPECallHandling::CPECallHandling

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

// might leave.

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

//

CPECallHandling::CPECallHandling(

    MPEPhoneModelInternal& aModel,

    CCCE& aConvergedCallEngine,

    MCCEDtmfInterface& aDtmfInterface

    ) : iModel( aModel ),

        iConvergedCallEngine( aConvergedCallEngine ),

        iDtmfInterface( aDtmfInterface ),

        iReplaceActive( EFalse ),

        iDialRequest( EFalse )

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::CPECallHandling()");

    }

// Destructor

EXPORT_C CPECallHandling::~CPECallHandling()

    {  

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::~CPECallHandling() start");

    delete iSystemCallState;

    delete iDtmfHandling;

    // No need to uninitialize feature manager - this is done in MPEPhoneModelInternal .cpp

    delete iSupplementaryServicesMonitor;

    delete iCCEObserver;

    delete iVideoCallHandling;

    delete iConferenceCall;

    delete iCallArrayOwner;

    delete iPsetSAObserver;

    delete iCallOpenParams;

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::~CPECallHandling() complete");    

    }

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

// CPECallHandling::NewL

// Two-phased constructor.

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

//

EXPORT_C CPECallHandling* CPECallHandling::NewL(

        MPEPhoneModelInternal& aModel,                    

        CCCE& aConvergedCallEngine,

        MCCEDtmfInterface& aDtmfInterface )

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::NewL start." );

    CPECallHandling* self = new (ELeave) CPECallHandling( aModel,

        aConvergedCallEngine, aDtmfInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::NewL complete." );

    return self;

    }

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

// CPECallHandling::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPECallHandling::ConstructL()

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::BaseConstructL() start"); 

    // Creates a supplementary services monitor

    iSupplementaryServicesMonitor = new (ELeave) CPESupplementaryServicesMonitor( 

        *this, *iModel.DataStore() );

    iCCEObserver = CPECCEObserver::NewL( *this, iModel );

    iConvergedCallEngine.SetObserver( *iCCEObserver, *iSupplementaryServicesMonitor );

    // Creates CPEDtmfSender object

    iDtmfHandling = CPEDtmfHandling::NewL( *this, iDtmfInterface );

    // Creates a call array owner object

    iCallArrayOwner = CPECallArrayOwner::NewL( 

            iConvergedCallEngine, 

            *this );

    iVideoCallHandling = CPEVideoCallHandling::NewL( 

            *this, 

            iModel, 

            iConvergedCallEngine,

            *iCallArrayOwner );

    iCallOpenParams = CCCECallParameters::NewL();

    iSystemCallState = CPESystemCallState::NewL( *iCallArrayOwner, *iModel.DataStore() );

    TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::BaseConstructL() complete");

    }

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

// CPECallHandling::SendErrorMessage

// Reroutes error messages to the Phone Engine, usable by other than call objects

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

//

void CPECallHandling::SendErrorMessage(

        const TInt aErrorCode )

    {

    TEFLOGSTRING2( KTAINT, 

        "CALL CPECallHandling::SendErrorMessage, error code: %d", 

        aErrorCode );

    iModel.DataStore()->SetErrorCode( aErrorCode );

    iModel.SendMessage( MEngineMonitor::EPEMessageCallHandlingError );

    }

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

// CPECallHandling::SendErrorMessage

// Reroutes error messages to the Phone Engine, usable by call objects

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

//

void CPECallHandling::SendErrorMessage( 

        const TInt aCallId,

        const TInt aErrorCode )

    {

    TEFLOGSTRING3( KTAINT, 

        "CALL CPECallHandling::SendErrorMessage, error code: %d, call id: %d", 

        aErrorCode,

        aCallId );

    // Dial request failed - resume held call

    if( aErrorCode == ECCPErrorInvalidFDN )

        {

        HandleAutoResume();

        }

    if ( aCallId == KPECallIdNotUsed )

        {

        SendErrorMessage( aErrorCode );

        }

    else

        {

        iModel.DataStore()->SetErrorCode( aErrorCode );

        iModel.SendMessage( MEngineMonitor::EPEMessageCallHandlingError, aCallId );

        //Handle call objet deleting if dialing fail.

        if( ECCPErrorNone != aErrorCode )

            {

            CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

            if( callData )

                {

                TEFLOGSTRING2( KTAINT, 

                    "CALL CPECallHandling::SendErrorMessage, call state %d", callData->GetCallState() );

                if( callData->GetCallState() == EPEStateIdle )

                    {

                    ReleaseCallObject( aCallId  );

                    iDialRequest = EFalse;

                    }

                }

            }

        if( ( KPEConferenceCallID == aCallId ) && ( ECCPConferenceErrorAddCall == aErrorCode ) &&

              iConferenceCall && ( iConferenceCall->EnumerateCalls() == 0 ) )

           { 

           delete iConferenceCall; 

           iConferenceCall = NULL;

           iModel.DataStore()->ResetCallInfo( aCallId );

           } 

        }

    }

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

// CPECallHandling::SendMessage

// Reroutes messages to the Phone Engine, usable by other than call objects

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

//

void CPECallHandling::SendMessage( 

    MEngineMonitor::TPEMessagesFromPhoneEngine aMessage )

    {

    TEFLOGSTRING2( KTAINT,

        "CALL CPECallHandling::SendMessage, message id: %d", aMessage );

    iModel.SendMessage( aMessage );

    }

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

// CPECallHandling::SendMessage

// Reroutes messages to the Phone Engine, usable by call objects

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

//

void CPECallHandling::SendMessage( 

    MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,

    TInt aCallId )

    {

    TEFLOGSTRING3( KTAINT, 

        "CALL CPECallHandling::SendMessage, message id: %d, call id: %d", 

        aMessage, 

        aCallId );

    TInt errorCode( KErrNone );

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageDialing:

            {

            iDialRequest = EFalse;

            CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

            if( callData )

                {

                MCCECall& call = callData->Call();

                iModel.DataStore()->SetCallIndex(call.CallIndex(), aCallId );                

                SetCallOrigin( aCallId, call );                        

                }  

            break;

            }

        case MEngineMonitor::EPEMessageChangedCallDuration:

            {

            TTimeIntervalSeconds duration;

            errorCode = GetCallDuration( duration, aCallId );

            if ( errorCode == KErrNone )

                {

                iModel.DataStore()->SetCallDuration( duration, aCallId );

                }

            break;

            }

        case MEngineMonitor::EPEMessageIdle:

            {

            HandleAutoResume();

            break;

            }

        case MEngineMonitor::EPEMessageAddedConferenceMember:

            {

            TName memberName;

            TInt count;

            errorCode = GetNumberOfParticipants( count );

            TEFLOGSTRING2( 

                KTAMESIN, 

                "CALL CPECallHandling::SendMessage EPEMessageAddedConferenceMember errorCode %d", 

                errorCode );

            if ( errorCode == KErrNone )

                {

                iModel.DataStore()->SetNumberOfConferenceMembers( count, KPEConferenceCallID );

                iConferenceCall->GetConferenceMemberName( memberName );

                if ( errorCode == KErrNone )

                    {

                    iModel.DataStore()->SetConferenceMemberInfo( 

                        memberName, 

                        KPEConferenceCallID, 

                        aCallId );

                    iModel.DataStore()->SetCallConference( aCallId, 

                            KPEConferenceCallID );

                    }

                }

            break;

            }

        case MEngineMonitor::EPEMessageDroppedConferenceMember:                

            {

            TName memberName;

            TInt memberCallId;

            TInt count;

            errorCode = GetNumberOfParticipants( count );

            TEFLOGSTRING2( 

                KTAMESIN, 

                "CALL CPECallHandling::SendMessage EPEMessageAddedConferenceMember EPEMessageDroppedConferenceMember %d", 

                errorCode );

            if ( errorCode == KErrNone )

                {

                iModel.DataStore()->SetNumberOfConferenceMembers( count, KPEConferenceCallID );

                errorCode = GetConferenceMemberNameAndId( memberName, 

                                                          memberCallId );

                // Member has been taken to OneToOne conversation and is still alive

                if ( errorCode == KErrNone )

                    {

                    iModel.DataStore()->SetConferenceMemberInfo( 

                        memberName, 

                        KPECallIdNotUsed, 

                        aCallId );

                    iModel.DataStore()->SetCallConference( 

                        KPENormalVoiceCall,

                        memberCallId );

                    }

                else

                    {

                    // Member has been dropped and its state is idle, so no 

                    // information can be found...

                    // So actually not an error situation memberName is empty

                    // (set in GetConferenceMemberNameAndId method) 

                    iModel.DataStore()->SetConferenceMemberInfo( 

                        memberName, 

                        KPECallIdNotUsed, 

                        aCallId );

                    errorCode = KErrNone;

                    }

                }                

            break;    

            }

        case MEngineMonitor::EPEMessageCallControlCapsChanged: 

            {

            TPECallControlCaps callControlCaps;

            errorCode = GetCallControlCaps( callControlCaps, aCallId );

            if ( errorCode == KErrNone )

                {

                iModel.DataStore()->SetCallControlCaps( 

                    callControlCaps, 

                    aCallId );

                }

            break;

            }

        case MEngineMonitor::EPEMessageConferenceCapsChange:                             

            {

            TUint32 caps;

            errorCode = GetConferenceCallCaps( caps );

            if ( errorCode == KErrNone )

                {

                iModel.DataStore()->SetConferenceCallCaps( caps, aCallId );

                }

            break;    

            }

        case MEngineMonitor::EPEMessageDisconnecting:

            {

            CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

            if ( callData )

                {

                TCCPTone inbandTone = callData->Tone();

                iModel.DataStore()->SetInbandTone( inbandTone );

                }

            break;

            }

        case MEngineMonitor::EPEMessageConferenceErrorAddCall:

        case MEngineMonitor::EPEMessageConferenceErrorRemoveCall:

        case MEngineMonitor::EPEMessageConferenceErrorSwap:

        case MEngineMonitor::EPEMessageConferenceErrorHold:

        case MEngineMonitor::EPEMessageConferenceErrorResume:

        case MEngineMonitor::EPEMessageConferenceErrorGoOneToOne:

        case MEngineMonitor::EPEMessageConferenceErrorCurrentCallsToConference:

            {

            errorCode = KErrGeneral;

            if( iConferenceCall && ( iConferenceCall->EnumerateCalls() == 0 ) )

                {

                delete iConferenceCall;

                iConferenceCall = NULL;

                }

            break;

            }

        case MEngineMonitor::EPEMessageCallSecureStatusChanged:

            {

            iModel.DataStore()->SetCallSecureStatus( 

                IsSecureCall( aCallId ), 

                aCallId );

            // Secure is specified  

            iModel.DataStore()->SetSecureSpecified( ETrue );

            break;

            }          

        case MEngineMonitor::EPEMessageSecureNotSpecified:

            {

            iModel.DataStore()->SetSecureSpecified( EFalse );

            break;

            }                     

        case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

            {

            TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged");

            // HO cases call type can changes

            CPESingleCall* connectedCall;

            connectedCall = iCallArrayOwner->CallPointerByState( EPEStateConnected );

            if( connectedCall )

                {

                CCPCall::TCallType callType = connectedCall->Call().Parameters().CallType();

                if ( callType == CCPCall::ECallTypePS ) 

                    {

                    TEFLOGSTRING( KTAMESINT, 

                        "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged->update call type to PS");

                    iModel.DataStore()->SetCallType( EPECallTypeVoIP, aCallId ); 

                    iModel.DataStore()->SetServiceIdCommand( connectedCall->Call().Parameters().ServiceId() );

                    iCallOpenParams->SetCallType( CCPCall::ECallTypePS); 

                    }

                else if ( callType == CCPCall::ECallTypeCSVoice )

                    {

                     TEFLOGSTRING( KTAMESINT, 

                        "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged->update call type to CS");

                    iCallOpenParams->SetCallType( CCPCall::ECallTypeCSVoice );

                    iModel.DataStore()->SetServiceIdCommand( 1 );

                    iModel.DataStore()->SetCallType( EPECallTypeCSVoice, aCallId );    

                    }

                }

            }

       // Flow throught

        case MEngineMonitor::EPEMessageIncoming:

            {

            CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

            if( callData )

                {

                MCCECall& call = callData->Call();

                iModel.DataStore()->SetRemotePartyName( call.RemotePartyName(), aCallId );

                iModel.DataStore()->SetCallIndex(call.CallIndex(), aCallId );

                }

            break;

            }

        case MEngineMonitor::EPEMessageForwardUnconditionalModeActive:

            {

            UpdateSaSetting();

            break;

            }

        case MEngineMonitor::EPEMessageUnattendedTransferRequest:

            {

            CPESingleCall* call = iCallArrayOwner->GetCallObject( aCallId );

            __ASSERT_DEBUG( NULL != call, Panic( EPEPanicIllegalCommand ) );

            if ( call )

                {

                iModel.DataStore()->SetUnattendedTransferTarget( 

                    call->UnattendedTransferTarget(), aCallId );

                }

            break;

            }

        case MEngineMonitor::EPEMessageALSLineChanged:

            {

            SetActiveLine();

            break;

            }

        case MEngineMonitor::EPEMessageMovedPermanently:

        case MEngineMonitor::EPEMessageMultipleChoices:

            {

            /* Incoming moved permanently request from server,

             * store target addresses for later use

             */

            CPESingleCall* call = iCallArrayOwner->GetCallObject( aCallId );

            __ASSERT_DEBUG( NULL != call, Panic( EPEPanicIllegalCommand ) );

            if ( call )

                {

                iModel.DataStore()->SetForwardAddressChoices( 

                    call->ForwardAddressChoices(), aCallId );

                }

            break;

            }

        default:

            // Other messages cause no action.

            break;

        } 

    if( aCallId != KPECallIdNotUsed )

        {

        // Preferred to be before sendmessage

        // f.e active idle update before display to screen

        iSystemCallState->NotifySystemCallStateChanged( aMessage, aCallId );

        }