/*

* Copyright (c) 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:  Manual call control handler

*

*/

// INCLUDE FILES

#include "cpemanualcallcontrolhandler.h"

#include "cpemessagehandler.h"

#include <ccpdefs.h>

#include <mpecallhandling.h>

#include <mpedatastore.h>

#include <pepanic.pan>

#include <pevirtualengine.h>

#include <talogger.h>

// EXTERNAL DATA STRUCTURES

// None.

// EXTERNAL FUNCTION PROTOTYPES  

// None.

// CONSTANTS

// None.

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

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

// cpemanualcallcontrolhandler::CPEManualCallControlHandler

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

// might leave.

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

//

CPEManualCallControlHandler::CPEManualCallControlHandler( 

        MPECallHandling& aCallHandling,

        CPEMessageHandler& aMessageHandler,

        MPEDataStore& aDataStore )

        :   iCallHandling( aCallHandling ),

            iMessageHandler( aMessageHandler ),

            iDataStore( aDataStore )

    {

    }

// Destructor

CPEManualCallControlHandler::~CPEManualCallControlHandler()

    {

    }

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

// CPEManualCallControlHandler::NewL

// Two-phased constructor.

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

//

CPEManualCallControlHandler* CPEManualCallControlHandler::NewL

        ( 

        MPECallHandling& aCallHandling,

        CPEMessageHandler& aMessageHandler,

        MPEDataStore& aDataStore )

    {

    CPEManualCallControlHandler* handler = new ( ELeave ) CPEManualCallControlHandler( 

        aCallHandling, 

        aMessageHandler,

        aDataStore);

    return handler;

    }

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

// CPEManualCallControlHandler::HandleChldL

// Handles common Chld (swap, answer waiting call, ... )

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

//

void CPEManualCallControlHandler::HandleChldL( 

            const TPhCltChldCommand aChldCommand,

            const TUint aCallNo )

    {

    TEFLOGSTRING3( KTAMESINT, 

            "PE CPEManualCallControlHandler::HandleChldL, aChldCommand: %d, aCallNo: %d"

            , aChldCommand

            , aCallNo ); 

    TInt error( KErrNotFound );

    switch ( aChldCommand )

        {

        case EPhCltChldZero:

            // Release held calls or set UDUB for a waiting call.

            error = HandleChldZero();

            break;

        case EPhCltChldOne:

            // Release all active calls and accept other (held or waiting) call.

            {

            if( aCallNo )

                {

                HandleChldOneXL( aCallNo );

                error = ECCPErrorNone;

                }

            else

                {

                error = HandleChldOne();

                }

            }

            break;

        case EPhCltChldTwo:

            // Place all active calls on hold and accept the other (held or waiting) call.

            {

            if( aCallNo )

                {

                HandleChldTwoXL( aCallNo );

                error = ECCPErrorNone;

                }

            else

                {

                error = HandleChldTwo();

                }

            }

            break;

        case EPhCltChldThree:

            // Add a held call to the conversation.

            error = HandleChldThree();

            break;

        case EPhCltChldFour:

            // Connect the two calls and disconnect the subscriber from 

            // both calls (Explicit call transfer).

            error = HandleChldFour();

            break;

        default:

            {

            TEFLOGSTRING2( KTAERROR, 

                "PE CPEManualCallControlHandler::HandleChldL, aChldCommand; %d"

                ,aChldCommand );

            break;

            }

        }

    User::LeaveIfError( error );     

    }

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

// CPEManualCallControlHandler::HandleChldZero

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

//

TInt CPEManualCallControlHandler::HandleChldZero()

    {

    TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldZero" );

    TInt error( ECCPErrorNotAllowed );

    if ( iCallHandling.IsCallInState( EPEStateRinging ) )

        {

        error = iCallHandling.RejectCall();

        }

    else if( iDataStore.ConferenceCallState( ) == EPEStateHeldConference )

        {

        iDataStore.SetCallId( KPEConferenceCallID );

        error = iMessageHandler.HandleReleaseCall();

        }

    else if ( iCallHandling.IsCallInState( EPEStateHeld ) )

        {

        TInt callId = iCallHandling.GetCallIdByState( EPEStateHeld );

        if ( callId != KPECallIdNotUsed )

            {

            iDataStore.SetCallId( callId );

            error = iMessageHandler.HandleReleaseCall();

            }

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldZero, error: %d", error );

    return error;  

    } 

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

// CPEManualCallControlHandler::HandleChldOne

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

//

TInt CPEManualCallControlHandler::HandleChldOne()

    {

    TEFLOGSTRING( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldOne" );

    TInt error( ECCPErrorNotAllowed );

    // Find active call

    TInt callId( KPECallIdNotUsed );

    if ( ( iDataStore.ConferenceCallState( ) == EPEStateConnectedConference ) )

        {

        callId = KPEConferenceCallID;

        }

    else if ( iCallHandling.IsCallInState( EPEStateConnected ) )

        {

        callId = iCallHandling.GetCallIdByState( EPEStateConnected );

        }

    else if ( iCallHandling.IsCallInState( EPEStateConnecting ) )  

        {

        callId = iCallHandling.GetCallIdByState( EPEStateConnecting );

        }

    else if ( iCallHandling.IsCallInState( EPEStateDialing ) )  

        {

        callId = iCallHandling.GetCallIdByState( EPEStateDialing );

        }

    else if ( iCallHandling.IsCallInState( EPEStateAnswering ) )  

        {

        callId = iCallHandling.GetCallIdByState( EPEStateAnswering );

        }

    // Replace 

    if ( iCallHandling.IsCallInState( EPEStateConnected ) &&

         iCallHandling.IsCallInState( EPEStateRinging ) )

        {

        TInt callIdConn = iCallHandling.GetCallIdByState( EPEStateConnected );

        TInt callIdRing = iCallHandling.GetCallIdByState( EPEStateRinging );

        if ( iDataStore.CallType( callIdConn ) == iDataStore.CallType( callIdRing ) )

            {

            // Replace allowed for same call types

            error = iCallHandling.ReplaceActive();

            }

        }

    else 

        {

         // Relese active call

        if ( callId != KPECallIdNotUsed )

            {

            iDataStore.SetCallId( callId );

            error = iMessageHandler.HandleReleaseCall( ETPEHangUpResumeHeldCall );

            }

        // accept held or waiting call

        if ( iCallHandling.IsCallInState( EPEStateRinging ) )    

            {

            error = iCallHandling.AnswerCall();

            }

        else if ( iCallHandling.IsCallInState( EPEStateHeld ) )  

            {

            error = iCallHandling.ResumeCall();

            }    

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldOne, error: %d", error );    

    return error;         

    }

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

// CPEManualCallControlHandler::HandleChldOneXL

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

//

void CPEManualCallControlHandler::HandleChldOneXL( TInt aCallNo )

    {

    TEFLOGSTRING2( KTAINT,

        "PE CPEManualCallControlHandler::HandleChldOneXL, aCallNo %d", 

        aCallNo );

    TInt error( ECCPErrorNotAllowed );

    TPEState callState;

    if ( ( KPEMaximumNumberOfVoiceCalls > aCallNo ) && ( aCallNo > 0 ) ) 

        {

        callState = iDataStore.CallState( CallIdByIndexL( aCallNo ) );

        TEFLOGSTRING2( KTAINT,

            "PE CPEManualCallControlHandler::HandleChldOneXL, callState %d", 

            callState );

        if ( callState == EPEStateRinging && 

             !( iCallHandling.IsCallInState( EPEStateDialing ) || iCallHandling.IsCallInState( EPEStateConnecting ) ) )

            {

            error = iMessageHandler.HandleAnswerCall( EFalse );

            TEFLOGSTRING2( KTAINT,

            }

        else if ( callState == EPEStateConnected )

            {

            iDataStore.SetCallId( CallIdByIndexL( aCallNo ) );

            error = iMessageHandler.HandleReleaseCall( ETPEHangUpNotResumeHeldCall );

            TEFLOGSTRING2( KTAINT,

            }

        }        

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldOneXL, error: %d", error );    

    User::LeaveIfError( error );        

    }

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

// CPEManualCallControlHandler::HandleChldTwo

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

//

TInt CPEManualCallControlHandler::HandleChldTwo()

    {

    TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldTwo");

    TInt error( ECCPErrorNotAllowed );

    if ( iCallHandling.IsCallInState( EPEStateDialing ) || 

         iCallHandling.IsCallInState( EPEStateConnecting ) )

        {

        TEFLOGSTRING( 

            KTAERROR, 

        }

    else

        {

        if ( iCallHandling.IsCallInState( EPEStateConnected ) && 

             iCallHandling.IsCallInState( EPEStateHeld ) )

            {

            error = iCallHandling.SwapCalls();

            }

        else if ( iCallHandling.IsCallInState( EPEStateConnected ) && 

                  !iCallHandling.IsCallInState( EPEStateRinging ) )

            {

            error = iCallHandling.HoldCall();

            }

        else if ( iCallHandling.IsCallInState( EPEStateHeld ) &&

            !( iCallHandling.IsCallInState( EPEStateRinging ) ) )

            {

            error = iCallHandling.ResumeCall();

            }

        else if ( iCallHandling.IsCallInState( EPEStateRinging ) )

            {

            error = iCallHandling.AnswerCall();

            }

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldtwo, error: %d", error );    

    return error; 

    }

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

// CPEManualCallControlHandler::HandleChldTwoXL

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

//

void CPEManualCallControlHandler::HandleChldTwoXL( TInt aCallNo )

    {

    TEFLOGSTRING( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldTwoXL" );

    TInt error( ECCPErrorNotAllowed );

    if ( ( KPEMaximumNumberOfVoiceCalls > aCallNo ) && ( aCallNo > 0 ) ) 

        {   

        if ( ( iDataStore.CallState( CallIdByIndexL( aCallNo ) ) ==  EPEStateConnected )

            && ( iDataStore.ConferenceCallState( ) == EPEStateConnectedConference ) )

            {

            iDataStore.SetCallId( CallIdByIndexL( aCallNo ) );

            error = iMessageHandler.HandleGoOneToOne();

            }

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldTwoXL, error: %d", error );    

    User::LeaveIfError( error );       

    }

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

// CPEManualCallControlHandler::HandleChldThree

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

//

TInt CPEManualCallControlHandler::HandleChldThree()

    {

    TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree");

    TInt error( ECCPErrorNotAllowed );

    if( iDataStore.ConferenceCallState( ) == EPEStateConferenceIdle ) 

        {

        TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree: HandleBuildConferenceCall" );

        error = iMessageHandler.HandleBuildConferenceCall();

        }

    else if ( iDataStore.ConferenceCallState( ) == EPEStateConnectedConference )

        {

        TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree: EPEStateConnectedConference" );

        if ( iCallHandling.IsCallInState( EPEStateHeld ) )

            {

            TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree: AddConferenceMember" );

            error = iCallHandling.AddConferenceMember();

            }

        }

    else if( iDataStore.ConferenceCallState( ) == EPEStateHeldConference ) 

        {

        TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree: EPEStateHeldConference" );

        if ( iCallHandling.IsCallInState( EPEStateConnected ) )

            {

            TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldThree: AddConferenceMember" );

            error = iCallHandling.AddConferenceMember();

            }

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldTree, error: %d", error );

    return error;         

    }

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

// CPEManualCallControlHandler::HandleChldFour

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

//

TInt CPEManualCallControlHandler::HandleChldFour()

    {

    TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldFour" );

    TInt error( ECCPErrorNotAllowed );

    if ( ( iCallHandling.IsCallInState( EPEStateConnected ) || iCallHandling.IsCallInState( EPEStateConnecting ) ) && 

         iCallHandling.IsCallInState( EPEStateHeld ) )

        {

        TEFLOGSTRING( KTAINT, "PE CPEManualCallControlHandler::HandleChldFour > TransferCalls" );

        error = iCallHandling.TransferCalls();

        }

    TEFLOGSTRING2( KTAINT, 

        "PE CPEManualCallControlHandler::HandleChldFour, error: %d", error );

    return error;        

    }

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

// CPEManualCallControlHandler::CallIdByIndexL

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

//

TInt CPEManualCallControlHandler::CallIdByIndexL( const TInt& aCallIndex )

    {

    TInt i, errorCode( ECCPErrorNotAllowed );

    for( i = 0; i < KPEMaximumNumberOfCalls; i++ )

        {

        if( iDataStore.CallIndex( i ) == aCallIndex )

            {

            errorCode = ECCPErrorNone;

            break;

            }

        }

    User::LeaveIfError( errorCode );

    return i;

    }

//  End of File