/*

* Copyright (c) 2005 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:    

*

*/

// MCE API

#include <ecam.h>

#include <MCEManager.h>

#include <Mcedefs.h>

#include <MCEOutSession.h>

#include <mcerefer.h>

#include <MCEAudioStream.h>

#include <MCEAudioStream.h>

#include <mcevideostream.h>

#include <MCEMicSource.h>

#include <MCERtpSink.h>

#include <MCERtpSource.h>

#include <MCESpeakerSink.h>

#include <mcecamerasource.h>

#include <mcedisplaysink.h>

#include <MCEmediaSink.h>

#include <MCEFileSource.h>

#include <Uri8.h>

#include <mcefilesink.h>

#include <MCEAudioCodec.h>

#include <MCEVideoCodec.h>

#include <MCEAMRCodec.h>

#include <MCEFCMsgExchange.h>

#include <mcestreambundle.h>

#include <mcesecureoutsession.h>

#include <mcesecuresession.h>

#include <aknutils.h>

#include <mceavccodec.h>

#include "MCETestUIEngineDefaultValues.h"

#include "CMCETestUIQuestionDataQuery.h"

#include "CMCETestUIEngine.h"

#include "CMCETestUIEngineProfileContainer.h"

#include "CMCETestUIEngineProfile.h"

#include "CMCETestUIEngineOutSession.h"

#include "TMCETestUIEngineCmdEstablish.h"

#include "TMCETestUIEngineCmdCancelSession.h"

#include "TMCETestUIEngineCmdDeleteSession.h"

#include "TMCETestUIEngineCmdFloorControlSession.h"

#include "CMCETestUIEngineMultimediaObserver.h"

#include "TMCETestUIEngineCmdCryptoHandling.h"

#include "TMCETestUIEngineCmdSRReqRes.h"

//const TUint KAudioPrefAudioUplink                      = 0x05220001;

//const TUint KAudioPrefAudioDownlink                    = 0x05210001;

const TUint KJitterBufferInactTimeout 					  = 10000;

_LIT8( KMCERtpSinkIdentity, "RtpSink@multimedia.engine.com" ); 

_LIT8( KMCERtpSourceIdentity, "RtpSource@multimedia.engine.com" ); 

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

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

// CMCETestUIEngineOutSession::NewL()

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

//

CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL(

            CMCETestUIEngine& aEngine,

            CMCETestUIEngineProfile& aProfile,

            TDirection aDirection,

            TVideoDirection aVideoDirection,

            TSessionType aSessionType ) 

    {

    CMCETestUIEngineOutSession* self = 

        new (ELeave) CMCETestUIEngineOutSession( aEngine, 

                                                 aProfile,

                                                 aDirection,

                                                 aVideoDirection,

                                                 aSessionType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;  

    }

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

// CMCETestUIEngineOutSession::NewL()

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

//

CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL(

            CMCETestUIEngine& aEngine,

            TUint32 aIAPId,

            TDirection aDirection,

            TVideoDirection aVideoDirection,

            TSessionType aSessionType ) 

    {

    CMCETestUIEngineOutSession* self = 

        new (ELeave) CMCETestUIEngineOutSession( aEngine, 

                                                 aIAPId,

                                                 aDirection,

                                                 aVideoDirection,

                                                 aSessionType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;  

    }

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

// CMCETestUIEngineOutSession::NewL()

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

//

CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL(

            CMCETestUIEngine& aEngine,

            CMceRefer &aRefer,

            TDirection aDirection,

            TVideoDirection aVideoDirection,

            TSessionType aSessionType ) 

    {

    CMCETestUIEngineOutSession* self = 

        new (ELeave) CMCETestUIEngineOutSession( aEngine, 

                                                 aRefer,

                                                 aDirection,

                                                 aVideoDirection,

                                                 aSessionType );

    CleanupStack::PushL( self );

    self->ConstructL(aRefer);

    CleanupStack::Pop( self );

    return self;  

    }

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

// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession

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

//

CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( 

                CMCETestUIEngine& aEngine,

                CMCETestUIEngineProfile& aProfile,

                TDirection aDirection,

                TVideoDirection aVideoDirection,

                TSessionType aSessionType )

    : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ),

      iProfile( &aProfile ),

      iId( 0 ),

      iSessionType(aSessionType),

      iIapId ( 0xFF )

    {

    }

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

// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession

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

//

CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( 

                CMCETestUIEngine& aEngine,

                TUint32 aIAPId,

                TDirection aDirection,

                TVideoDirection aVideoDirection,

                TSessionType aSessionType )

    : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ),

      iIapId( aIAPId ),

      iId( 0 ),

      iSessionType(aSessionType),

      iProfile ( NULL )

    {

    }

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

// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession

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

//

CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( 

                CMCETestUIEngine& aEngine,

                CMceRefer &aRefer,

                TDirection aDirection,

                TVideoDirection aVideoDirection,

                TSessionType /*aSessionType*/ )

    : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ),

      iId( 0 ),

      iRefer(&aRefer)

    {

    }

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

// CMCETestUIEngineOutSession::ConstructL()

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

//

void CMCETestUIEngineOutSession::ConstructL()

    {

     /////////////////////

    //

    // TODO: After implementing wrappers for streams, sinks and sources 

    //       this function should be refactored to make use of them. That will 

    //       also simplify the function to some extent.

    //

    //////////////////////

    BaseConstructL();

    FillProfileRegistrar();   

    FillPoCOrigAddress();

    if( SessionParamsL(iSessionParams,iSessionType) )

        {

    	// set rtcp flag

    	 if(iEngine.iRtcpFlag == EFalse)

    	 	{

    	 	iEngine.iSRCount = 0;

    		iEngine.iRRCount = 0;	

    	 	}

    	 // Solve recipient

	    CMCETestUIQuestionDataQuery* question = 

		    CMCETestUIQuestionDataQuery::NewLC();

        question->SetCaptionL( KUserQuestionInputRecipient );

    	question->SetDefaultValueL(iSessionParams.iRecipentAddress  );

    	question->SetAnswerL( iSessionParams.iRecipentAddress  );

    	TBufC8<300> recipient( question->Answer8() );

    	CleanupStack::PopAndDestroy( question );

		//////

		// solve originator

	    CMceOutSession* outSession = NULL;

	    if( iSessionParams.originator.Compare(KNone) )//if there is originator

	   	    {

		   	HBufC8* orig8 = HBufC8::NewL(iSessionParams.originator.Length());

		   	TPtr8 ptr = orig8->Des();

		    ptr.Copy(iSessionParams.originator);

		    // Create Outsession

		    if(iEngine.iOutSessionWithProfile)// thru profile

		    	{

		    	if( iSessionParams.iSecureSession )

		    		{

		    		iOutSession = 

		    				CMceSecureOutSession::NewL( iEngine.MCEManager(),

		                                                iProfile->Profile(),

		                                                recipient ,orig8);

		            if( iEngine.iSecureSessionAVP )

			    		{

			    		iOutSession->SetModifierL( KMceSecureSession, 

			    								   KMceSecurePlainAVP );

			    		} 

			        if ( iEngine.iSecPreconditions )

			    		{			    		

					    iOutSession->SetModifierL( KMceSecPreconditions, 

											   KMcePreconditionsE2ESupported );

			    		}	

		    		}

		    	else

		    		{

		    		iOutSession = CMceOutSession::NewL( iEngine.MCEManager(),

		                                            iProfile->Profile(),

		                                            recipient ,orig8);	

		    		}

		    	}

		    else ///thru accesspoint , it can be  done only with originator

		    	{

		    	iOutSession = CMceOutSession::NewL( iEngine.MCEManager(),

		                                           iIapId,ptr,recipient);

		    	}

	   	    }

	   	else  // if there is only recipent and no originator 

	   	    {

	   	    if ( iSessionParams.iSecureSession )

		    	{

		    	iOutSession = 

		    		CMceSecureOutSession::NewL( iEngine.MCEManager(), 

	                                            iProfile->Profile(),

	                                            recipient );

	            if ( iEngine.iSecureSessionAVP )

			    		{

			    		iOutSession->SetModifierL( KMceSecureSession, 

			    								   KMceSecurePlainAVP );

			    		} 

		    	if ( iEngine.iSecPreconditions )

			    		{			    		

						iOutSession->SetModifierL( KMceSecPreconditions, 

										KMcePreconditionsE2ESupported );

			    		}

		    	}

		    else

		    	{

		    	iOutSession = CMceOutSession::NewL( iEngine.MCEManager(), 

	                                            iProfile->Profile(),

	                                            recipient );

		    	}

	   	    }

	    iSession = iOutSession;

        if ( iSessionType == EPoCSession)

			{

		 	FillPoCSessionData(iOutSession);

			}

		else if (iSessionType == EVoIPSession)

			{

			FillVoIPSessionData(iOutSession);

			}

	    else if (iSessionType == E2WayVideoSession)

	        {

	        Fill2WayVideoSessionDataL(iOutSession);

	        }

		else if (iSessionType == ECustomSession)

			{

			FillCustomSessionData(iOutSession);

			}

		if ( iEngine.iHoldWithAddress )

    		{

    		iOutSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress );

    		} 

		if ( iEngine.IsFCSession() ) 

			{

			TRAP_IGNORE(iEngine.FloorControl().InitializeL(

												*iOutSession,0,iEngine.MMObserver()));

			CDesC8Array* array = NULL;

			array = new (ELeave) CDesC8ArrayFlat(1);	

		    array->AppendL(_L8("a=fmtp:TBCP queuing=1; tb_priority=0; timestamp=1; tb_granted=1; poc_sess_priority=1; poc_lock=1\r\n"));

			iEngine.FloorControl().UpdateL(*iOutSession, array);

			}

		if ( iEngine.iSdp )

			    {

			    CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(3);

			    array->AppendL(_L8("a=OutgoingSession1:20\r\n"));

                array->AppendL(_L8("a=OutgoingSession2:40\r\n"));

                array->AppendL(_L8("b=AS:64\r\n"));

			    iOutSession->SetSessionSDPLinesL( array );

			    }

        }

		    // Get identity

	    iId = iEngine.NextOutSessionId();

    	iType = KMceOutSession;

    }

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

// CMCETestUIEngineOutSession::ConstructSessionFromReferL()

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

//

void CMCETestUIEngineOutSession::ConstructL(CMceRefer& /*aRefer*/)

    {

     /////////////////////

    //

    // TODO: After implementing wrappers for streams, sinks and sources 

    //       this function should be refactored to make use of them. That will 

    //       also simplify the function to some extent.

    //

    //////////////////////

    BaseConstructL();

	    CMceOutSession* outSession = NULL;

	    iOutSession = CMceOutSession::NewL( *iRefer );

	    iSession = iOutSession;

        if ( iSessionType == ECustomSession)

			{

		//	FillCustomSessionData(iOutSession);

			FillVoIPSessionData(iOutSession);

			}

		if( iEngine.iHoldWithAddress )

    		{

    		iOutSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress );

    		} 

		if( iEngine.IsFCSession() ) 

			{

			TRAP_IGNORE(iEngine.FloorControl().InitializeL(

												*iOutSession,0,iEngine.MMObserver()));

			CDesC8Array* array = NULL;

			array = new (ELeave) CDesC8ArrayFlat(1);	

		    array->AppendL(_L8("a=fmtp:TBCP queuing=1; tb_priority=0; timestamp=1; tb_granted=1; poc_sess_priority=1; poc_lock=1\r\n"));

			iEngine.FloorControl().UpdateL(*iOutSession, array);

			}

		if( iEngine.iSdp )

		    {

		    CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(2);

		    array->AppendL(_L8("a=OutgoingSession1:20\r\n"));

            array->AppendL(_L8("a=OutgoingSession2:40\r\n"));

		    iOutSession->SetSessionSDPLinesL( array );

		    }

		    // Get identity

	    iId = iEngine.NextOutSessionId();

    	iType = KMceOutSession;

    }

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

// CMCETestUIEngineOutSession::~CMCETestUIEngineOutSession

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

//

EXPORT_C CMCETestUIEngineOutSession::~CMCETestUIEngineOutSession()

    {

    delete iOutSession;

    }

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

// CMCETestUIEngineOutSession::GetCommands

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

//

const RPointerArray<TMCETestUIEngineCmdBase>& 

            CMCETestUIEngineOutSession::GetCommandsL()

    {

    iCommands.ResetAndDestroy();

    // Get base class commands

    CMCETestUIEngineSession::GetCommandsL();

    // Get own commands       

    TInt state = iOutSession->State();

	switch( state ) 

		{

		case CMceSession::EIdle: 

		    iCommands.Append( new (ELeave) TMCETestUIEngineCmdEstablish( 

                                iEngine, *this ) );

            iCommands.Append( new (ELeave) TMCETestUIEngineCmdEstablishWithValues( 

                                iEngine, *this ) );

            iCommands.Append( new (ELeave) TMCETestUIEngineCmdFCSendSession( 

                                iEngine, *this ) );

            iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdDeleteSession( iEngine, *this ) );

		    if(iSession->Type() == KMceSessionSecure) 

		    	{

		    	iCommands.Append( new (ELeave) 

		        	TMCETestUIEngineCmdCurrentCryptoContext( iEngine, *this ) );

		        iCommands.Append( new (ELeave) 

		        	TMCETestUIEngineCmdSupportedCryptoContext( iEngine, *this ) );

		        iCommands.Append( new (ELeave) 

		        	TMCETestUIEngineCmdSetCryptoContext( iEngine, *this ) );

		       	}

		    break;

		case CMceSession::EOffering: 

		    iCommands.Append( new (ELeave) TMCETestUIEngineCmdCancelSession( 

                                iEngine, *this ) );

            iCommands.Append( new (ELeave) TMCETestUIEngineCmdFCSendSession( 

                                iEngine, *this ) );

			iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdDeleteSession( iEngine, *this ) );     

		    iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdSendInfo( iEngine, *this ) );

			iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdDTMFInfo( iEngine, *this ) );

		    iCommands.Append( new ( ELeave )

		    	TMCETestUIEngineCmdSendInfoResponse( iEngine, *this ) );

		    if(iSession->Type() == KMceSessionSecure) 

		    	{

		    	iCommands.Append( new (ELeave) 

		        	TMCETestUIEngineCmdCurrentCryptoContext( iEngine, *this ) );

		        iCommands.Append( new (ELeave) 

		        	TMCETestUIEngineCmdSupportedCryptoContext( iEngine, *this ) );

		        }

		    break;

		case CMceSession::EEstablished:

			if(VideoDirection() != EVideoNotSpesified)    

		    	{

		    	if(iEngine.IsVideoEnabled())

		    	{

		    	iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdDisableVideoSession( iEngine, *this ) );

		    	}

		    	else

		    	{

		    	iCommands.Append( new (ELeave) 

		        TMCETestUIEngineCmdEnableVideoSession( iEngine, *this ) );     		        

		    	}

		    	}

		    break;		

		default: 

		    break;

		}  

    return iCommands; 

    }

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

// CMCETestUIEngineOutSession::Id

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

//

EXPORT_C TInt CMCETestUIEngineOutSession::Id() const

    {

    return iId;

    }

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

// CMCETestUIEngineOutSession::OutSession

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

//

CMceOutSession& CMCETestUIEngineOutSession::OutSession()