// Copyright (c) 2008-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:

//

//  INCLUDE FILES

#include "cmmconferencecallgsmwcdmaext.h"

#include "cmmphonetsy.h"

#include "cmmconferencecalltsy.h"

#include "cmmvoicecalltsy.h"

#include "cmmcalllist.h"

#include "cmmcallgsmwcdmaext.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmmessagemanagerbase.h"

#include <etelmmerr.h> // etel error codes

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

CMmConferenceCallGsmWcdmaExt::CMmConferenceCallGsmWcdmaExt()

    {

    }

CMmConferenceCallGsmWcdmaExt::~CMmConferenceCallGsmWcdmaExt()

    {

    iMmConferenceCallTsy = NULL;

    }

CMmConferenceCallGsmWcdmaExt* CMmConferenceCallGsmWcdmaExt::NewL(

    CMmConferenceCallTsy* aMmConferenceCallTsy )

    {

    CMmConferenceCallGsmWcdmaExt* const conferenceCallGsmWcdmaExt = 

        new ( ELeave ) CMmConferenceCallGsmWcdmaExt();

    CleanupStack::PushL( conferenceCallGsmWcdmaExt );

    conferenceCallGsmWcdmaExt->iMmConferenceCallTsy = aMmConferenceCallTsy;

    conferenceCallGsmWcdmaExt->ConstructL();

    CleanupStack::Pop();

    return conferenceCallGsmWcdmaExt;

    }

void CMmConferenceCallGsmWcdmaExt::ConstructL()

    {

    ResetAttributes();

    }

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

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

// CMmConferenceCallGsmWcdmaExt::CreateConferenceL

// This method allows clients to create the initial conference call.

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

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

//

TInt CMmConferenceCallGsmWcdmaExt::CreateConferenceL(

    RMobileConferenceCall::TMobileConferenceStatus aStatus )

    {

    TInt ret = KErrNotReady;

    //This method allows clients to create the inital 3-way conference call. 

    //The phone must be in a state where there are two single voice calls, 

    //one on hold and the other connected or alerting the remote, called party. 

    //The TSY will reflect the conference creation capability by setting 

    //the KCapsJoin flags of the individual calls and the KCapsCreate flag 

    //of the conference call sub-session.

    //

    //In GSM mode, this method will complete when the TSY has received 

    //confirmation from the network that the conference call service has been 

    //successfully invoked.

    //This check is required because Add call uses same DOS operation to 

    //as this one. Therefore we don't want to continue if status is not

    //Idle.     

    if ( RMobileConferenceCall::EConferenceIdle == aStatus )

        {

        //We have to get 2 active status indications before the conference 

        //has really gone to active state.

        iCreateConferenceCounter = 2;

#ifndef USING_CTSY_DISPATCHER

        //send request to DOS

		// no packaged parameters for DOS call

		ret = iMmConferenceCallTsy->Phone()->MessageManager()->

            HandleRequestL( EMobileConferenceCallCreateConference );

#else

		// Pass down the call IDs of the active and held calls to be

		// joined in the conference.

		TInt heldCallId = iMmConferenceCallTsy->HeldCall()->CallId();

		TInt connectedCallId = iMmConferenceCallTsy->ConnectedCall()->CallId();

		CCallDataPackage package;

		package.SetCallIdAndMode(heldCallId, iMmConferenceCallTsy->HeldCall()->CallMode());

		package.PackData(&connectedCallId);

		ret = iMmConferenceCallTsy->Phone()->MessageManager()->

			HandleRequestL( EMobileConferenceCallCreateConference, &package);

#endif   // USING_CTSY_DISPATCHER

        }

    //return request result

    return ret;

    }

#ifndef USING_CTSY_DISPATCHER

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

// CMmConferenceCallGsmWcdmaExt::AddCallL

// Addition of a new call to an existing conference call. If 

// call object is not found by the name given as input parameter KErrArgument

// will be returned.

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

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

//

TInt CMmConferenceCallGsmWcdmaExt::AddCallL(

    const TName* aCallName,

    RMobileConferenceCall::TMobileConferenceStatus aStatus,

    CMmCallList* aCallList )

    {

    TInt ret = KErrArgument;

    // Get the call object that should be added to the conference call

    CMmCallTsy* mmCall = aCallList->GetMmCallByName( aCallName );

    if ( mmCall ) 

        {

        // Fetch the active call extension

        CMmCallGsmWcdmaExt* mmCallGsmWcdmaExt = static_cast<CMmCallGsmWcdmaExt*>( mmCall->ActiveCallExtension() );

        // Get the mobile call capabilities

        RMobileCall::TMobileCallCapsV1 mobileCallCaps;

        mmCallGsmWcdmaExt->GetMobileCallCapsV1(mobileCallCaps);

        // Only calls whose call control capabilities include KCapsJoin can be added to a conference call.

        if( !( RMobileCall::KCapsJoin & mobileCallCaps.iCallControlCaps ))

        	{ // Do not add the call to the conference since the call doesn't have KCapsJoin capability.

        	if(KMaxCallsInConference <= iMmConferenceCallTsy->NumberOfCallsInConference())

        		return KErrMMEtelMaxReached;

        	return ret;

        	} 

        RMobileCall::TMobileCallStatus callStatus = 

            mmCall->MobileCallStatus();

        //check that this call is not in hold or connected  state and 

        //conference call is not idle (=no reason to try this)

        if ( ( ( callStatus == RMobileCall::EStatusHold ) ||

                ( callStatus == RMobileCall::EStatusConnected ) )

            && ( RMobileConferenceCall::EConferenceIdle != aStatus ) )

            {

            // send request to DOS

            // only packed parameter for DOS call: Id of the call to be added

            CCallDataPackage callDataPackage;

            callDataPackage.SetCallIdAndMode( mmCall->CallId(), 

                RMobilePhone::EServiceUnspecified ); // service type not needed

            ret = iMmConferenceCallTsy->Phone()->MessageManager()->

                    HandleRequestL( EMobileConferenceCallAddCall,

                    &callDataPackage );

            }

        }

    return ret;

    }

#endif //USING_CTSY_DISPATCHER

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

// CMmConferenceCallGsmWcdmaExt::SwapL

// This method can be used to swap the ongoing conference call

// between active and held status. 

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

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

//

TInt CMmConferenceCallGsmWcdmaExt::SwapL(

	RMobileConferenceCall::TMobileConferenceStatus aStatus,

    CMmCallList* aCallList )

    {

TFLOGSTRING("TSY: CMmConferenceCallGsmWcdmaExt::SwapL");

	TInt ret = KErrArgument;

	// conference must be active or held

    if ( aStatus == RMobileConferenceCall::EConferenceIdle )

        {

        ret = KErrNotReady;

        }

    else

        {

        // Init counter

        iNumberOfCallsToBeSwapped = 0;

        CMmCallTsy* mmCall = NULL;

        CMmCallList* callList = iMmConferenceCallTsy->Phone()->CallList();

        // Check from call list the number of calls to be swapped

        for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ )

            {

            mmCall = callList->GetMmCallByIndex( i );

            if ( mmCall->IsPartOfConference() 

                && ( mmCall->MobileCallStatus() == RMobileCall::EStatusHold 

                || mmCall->MobileCallStatus() == RMobileCall::EStatusConnected ) )

                {

                // Call found, increase the counter.

                iNumberOfCallsToBeSwapped++;

                }

            }

TFLOGSTRING2("TSY: CMmConferenceCallGsmWcdmaExt::SwapL - Number of calls in conference: %d", iNumberOfCallsToBeSwapped);

        // Find active and held call objects:

        CMmCallTsy* mmActiveCall = 

            aCallList->GetMmCallByStatus( RMobileCall::EStatusConnected );

        CMmCallTsy* mmHeldCall = 

            aCallList->GetMmCallByStatus( RMobileCall::EStatusHold ); 

        if ( RMobileConferenceCall::EConferenceActive == aStatus )

            {

            // conference is active

            // if held call is found, swap operation is required

            if ( mmHeldCall )

                {

#ifndef USING_CTSY_DISPATCHER

                // need to swap

                // no packed parameters for DOS call

                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

                    HandleRequestL( EMobileConferenceCallSwap );

#else

                if (mmActiveCall && mmCall)

                	{

	                CCallDataPackage callDataPackage;

	                callDataPackage.SetCallIdAndMode( mmCall->CallId(),

	                		RMobilePhone::EServiceUnspecified ); // service type not needed

	                TInt heldCallId = mmHeldCall->CallId();

	                TInt connectedCallId = mmActiveCall->CallId();

	                callDataPackage.PackData(&heldCallId, &connectedCallId);

	                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

	                		HandleRequestL(EMobileConferenceCallSwap, &callDataPackage);

                	}

                else

                	{

                	ret = KErrNotReady; // Shouldn't happen

                	}

#endif // USING_CTSY_DISPATCHER

                }

            // if held call is not found, there should be an active call

	        // and hold operation is required

            else if ( mmActiveCall )

                {

                // need to hold the active (conference) call

                // create package; set call id and call mode

                CCallDataPackage package;

                package.SetCallIdAndMode( mmActiveCall->CallId(),

                    mmActiveCall->CallMode() );

                // send to DOS

                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

                    HandleRequestL( EMobileCallHold, &package );

                }

            // we have neither an active nor a held call

            else

                {

                ret = KErrNotReady; // should never happen

                }

            }

        else if ( RMobileConferenceCall::EConferenceHold == aStatus )

            {

            // conference is held

            //if active call is found, swap operation is required

            if ( mmActiveCall )

                {

#ifndef USING_CTSY_DISPATCHER

                // need to swap

                // no packed parameters for DOS call

                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

                    HandleRequestL( EMobileConferenceCallSwap );

#else

                if (mmHeldCall && mmCall)

                	{

	                CCallDataPackage callDataPackage;

	                callDataPackage.SetCallIdAndMode( mmCall->CallId(),

	                		RMobilePhone::EServiceUnspecified ); // service type not needed

	                TInt heldCallId = mmHeldCall->CallId();

	                TInt connectedCallId = mmActiveCall->CallId();

	                callDataPackage.PackData(&heldCallId, &connectedCallId);

	                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

	                		HandleRequestL(EMobileConferenceCallSwap, &callDataPackage);

                	}

                else

                	{

                	ret = KErrNotReady; // Shouldn't happen

                	}

#endif // USING_CTSY_DISPATCHER

                }

            // if active call is not found, there should be a held call

            // and resume operation is required

            else if ( mmHeldCall )

                {

                // need to retrieve (unhold) the held call

                // create package; set call id and call mode

                CCallDataPackage package;

                package.SetCallIdAndMode( mmHeldCall->CallId(),

                    mmHeldCall->CallMode() );

                // send to DOS

                ret = iMmConferenceCallTsy->Phone()->MessageManager()->

                    HandleRequestL( EMobileCallResume, &package );

                }

            // we have neither an active nor a held call

            else

                {

                ret = KErrNotReady; // should never happen

                }

            }

        }

    return ret;

    }

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

// CMmConferenceCallGsmWcdmaExt::CallStatusChanged

// After the status of a single call has changed, this method decides if

// the status of the conference call should be changed as well.

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

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

//

TBool CMmConferenceCallGsmWcdmaExt::CallStatusChanged(

    RMobileCall::TMobileCallStatus aNewStatus,

    TInt aCallId )

    {

TFLOGSTRING3("TSY: CMmConferenceCallGsmWcdmaExt::CallStatusChanged, aNewStatus:%d, aCallId:%d", aNewStatus, aCallId );

    TBool statusChanged( EFalse );

    //get current conference call status

    RMobileConferenceCall::TMobileConferenceStatus status 

            = iMmConferenceCallTsy->Status();

TFLOGSTRING2("TSY: CMmConferenceCallGsmWcdmaExt::CallStatusChanged, Current conf call iMmConferenceCallTsy->Status:%d ", status);

TFLOGSTRING2("TSY: CMmConferenceCallGsmWcdmaExt::CallStatusChanged, Current conference extension iNewStatus:%d ", iNewStatus);

    //get call list

    CMmCallList* callList = iMmConferenceCallTsy->Phone()->CallList();

    switch( aNewStatus )

        {

        //call has gone to idle state

        case RMobileCall::EStatusIdle:

            //If conference call is in active or held state 

            if ( ( RMobileConferenceCall::EConferenceActive == status ||

                   RMobileConferenceCall::EConferenceHold == status ) )           

                {

                //handle call releasing

                statusChanged = HandleCallRelease(

                    status, *callList, aNewStatus, aCallId );

                }

            break;

        //call has gone to held state

        case RMobileCall::EStatusHold:

            //if conference call is in active state

            if ( RMobileConferenceCall::EConferenceActive == status )

                {

                //check if swap request is pending

                if ( iMmConferenceCallTsy->ServiceRequested(

                        CMmConferenceCallTsy::EMultimodeConferenceCallSwap )

                     || iCurrentGhostOperation ==

                        RMobileConferenceCall::EConferenceSwapped )

                    {

                    //handle swapping

                    statusChanged = HandleSwap( status, *callList );

                    }

                //is GoOneToOne going on

                else if ( iGoOneToOneHandlingStarted )

                    {

                    statusChanged = HandleGoOneToOne( *callList, aCallId );

                    }

                //check that add call request is not pending

                else if ( !iMmConferenceCallTsy->ServiceRequested( 

                    CMmConferenceCallTsy::EMultimodeConferenceCallAddCall ) )

                    {

                    //Client has requested hold for a single call. If the call is part

                    //of the conference, all calls participating in the conference

                    //call will be held.

                    CMmCallTsy* call = callList->GetMmCallById(aCallId);

                    if(call != NULL && call->IsPartOfConference())

                    	{

                    	statusChanged = HandleSingleCallControl(status, aNewStatus);

                    	}

                    }

                }

            break;

        //call has gone to active state

        case RMobileCall::EStatusConnected:

            //check if CreateConference request is pending

            if ( ( iMmConferenceCallTsy->ServiceRequested(

                    CMmConferenceCallTsy::EMultimodeConferenceCallCreateConference )

                 || iCurrentGhostOperation == RMobileConferenceCall::EConferenceBuilt ) 

                 && RMobileConferenceCall::EConferenceIdle == status )

                {

                //handle create conference

                statusChanged = HandleCreateConference(

                    *callList, aCallId );

                }

            //check if AddCall request is pending

            else if ( ( iMmConferenceCallTsy->ServiceRequested(

                    CMmConferenceCallTsy::EMultimodeConferenceCallAddCall ) ||

                iCurrentGhostOperation ==  RMobileConferenceCall::EConferenceBuilt ||

                iCurrentGhostOperation ==  RMobileConferenceCall::EConferenceCallAdded ) &&

                ( RMobileConferenceCall::EConferenceActive == status ||

                RMobileConferenceCall::EConferenceHold == status ) )

                {

                //handle add call...

                statusChanged = HandleAddCall( status, *callList,

                    aNewStatus );

                }

            //check if swap request is pending

            else if ( iMmConferenceCallTsy->ServiceRequested(

                    CMmConferenceCallTsy::EMultimodeConferenceCallSwap ) ||

                iCurrentGhostOperation ==  RMobileConferenceCall::EConferenceSwapped )

                {

                //is conference status hold

                if ( RMobileConferenceCall::EConferenceHold == status )

                    {

                    //handle swap...

                    statusChanged = HandleSwap( status, *callList );

                    }

                }

            // call status might have changed because client has requested it

            // directly from a call object which is part of the conference

            // (not from the conference call object).

            else if ( RMobileConferenceCall::EConferenceHold == status )

                {

                CMmCallTsy* mmCall = callList->GetMmCallById( aCallId );

                if ( mmCall )

                    {

                    if ( mmCall->IsPartOfConference() )

                        {

                        // if this call is part of the conference, conference

                        // status is Hold and new call status is Connected, we

                        // have to get the whole conference into active state

                        statusChanged = HandleSingleCallControl(

                            status, aNewStatus );

                        }

                    }

                }

            break;

        case RMobileCall::EStatusUnknown:

        case RMobileCall::EStatusDialling:

        case RMobileCall::EStatusRinging:

        case RMobileCall::EStatusAnswering:

        case RMobileCall::EStatusConnecting:

        case RMobileCall::EStatusDisconnecting:

        case RMobileCall::EStatusDisconnectingWithInband:

        case RMobileCall::EStatusReconnectPending:

        case RMobileCall::EStatusWaitingAlternatingCallSwitch:

        case RMobileCall::EStatusTransferring:

        case RMobileCall::EStatusTransferAlerting:

        default:

            break;

        }

    if ( statusChanged )

        {

        // -1 indicates that there is no unhandled ghost operation anymore

        iCurrentGhostOperation = -1;

TFLOGSTRING("TSY: CMmConferenceCallGsmWcdmaExt::CallStatusChanged, statusChanged!! ");   

        }

TFLOGSTRING2("TSY: CMmConferenceCallGsmWcdmaExt::CallStatusChanged END, current conference extension iNewStatus:%d ", iNewStatus);

    return statusChanged;

    }

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

// CMmConferenceCallGsmWcdmaExt::SetGoOneToOneHandlingStarted

// Informs the Gsm extension if Go-One-To-One handling

// has started for any call.

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

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

//

void CMmConferenceCallGsmWcdmaExt::SetGoOneToOneHandlingStarted(

    TBool aVal,

    TInt aCallId )

    {

    iGoOneToOneHandlingStarted = aVal;

    iGoOneToOneCallId = aCallId;

    }

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

// CMmConferenceCallGsmWcdmaExt::CheckConferenceCapability

// Check if conference call creation is possible.

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

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

//

void CMmConferenceCallGsmWcdmaExt::CheckConferenceCapability(

    RMobileConferenceCall::TMobileConferenceStatus aStatus,

    CMmCallList* aCallList )

    {

TFLOGSTRING2("TSY: CMmConferenceCallGsmWcdmaExt::CheckConferenceCapability. aStatus:%d ", aStatus);     

    //Check if conference creation is possible. CC has to be in Idle state

    if ( RMobileConferenceCall::EConferenceIdle == aStatus  )

        {

        TUint8 connectedCount( 0 ); //how many calls are in active state

        TUint8 heldCount( 0 ); //how many calls are in hold state

        //number of calls in CallList

        TInt numberOfCallObjects = aCallList->GetNumberOfObjects();

        //check how many calls are in connected and held state

        for ( TInt i = 0; i < numberOfCallObjects; i++ )

            {

            CMmCallTsy* aMmCall = aCallList->GetMmCallByIndex( i );

            if ( aMmCall->MobileCallStatus() == 

                    RMobileCall::EStatusConnected )

                {

                //increment connected count

                connectedCount++;

                }

            else if ( aMmCall->MobileCallStatus() ==

                        RMobileCall::EStatusHold )

                {

                //increment held count

                heldCount++;

                }

            }