/*

* 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 <MCEManager.h>

#include <MCEOutSession.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 "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"

const TUint KAudioPriorityPocAudioUplink                  = 95;

const TUint KAudioPriorityPocAudioDownlink                = 95;

const TUint KAudioPrefPocAudioUplink                      = 0x05130001;

const TUint KAudioPrefPocAudioDownlink                    = 0x05120001;

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

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

// CMCETestUIEngineOutSession::NewL()

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

//

CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL(

            CMCETestUIEngine& aEngine,

            CMCETestUIEngineProfile& aProfile,

            CMCETestUIEngineOutSession::TDirection aDirection,

            CMCETestUIEngineOutSession::TVideoDirection aVideoDirection,

            CMCETestUIEngineOutSession::TSessionType aSessionType ) 

    {

    CMCETestUIEngineOutSession* self = 

        new (ELeave) CMCETestUIEngineOutSession( aEngine, 

                                                 aProfile,

                                                 aDirection,

                                                 aVideoDirection,

                                                 aSessionType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;  

    }

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

// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession

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

//

CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( 

                CMCETestUIEngine& aEngine,

                CMCETestUIEngineProfile& aProfile,

                CMCETestUIEngineOutSession::TDirection aDirection,

                CMCETestUIEngineOutSession::TVideoDirection aVideoDirection,

                CMCETestUIEngineOutSession::TSessionType aSessionType )

    : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ),

      iProfile( &aProfile ),

      iId( 0 ),

      iSessionType(aSessionType)

    {

    }

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

// 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))

    	{

    	 // Solve recipient

	   CMCETestUIQuestionDataQuery* question = 

		    CMCETestUIQuestionDataQuery::NewLC();

		question->SetCaptionL( KUserQuestionInputRecipient );

		question->SetDefaultValueL(iSessionParams.iRecipentAddress  );

		question->SetAnswerL( iSessionParams.iRecipentAddress  );

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

		CleanupStack::PopAndDestroy( question );

		//////

		// solve originator

	   if ( iSessionParams.originator.Compare(KNone))

	   	{

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

		   	TPtr8 ptr = orig8->Des();

		    ptr.Copy(iSessionParams.originator);

		    // Create Outsession

		    CMceOutSession* outSession = CMceOutSession::NewL(

	        iEngine.MCEManager(), 

	        iProfile->Profile(),

	        recipient ,orig8);

	    	CleanupStack::PushL(outSession);

	        if(iSessionType == EPoCSession)

				{

			 	FillPoCSessionData(outSession);

				}

			else if (iSessionType == ECustomSession)

				{

				FillCustomSessionData(outSession);

				}

			CleanupStack::Pop( outSession );

			if(iEngine.IsFCSession()) 

				{

				TRAP_IGNORE(iEngine.FloorControl().InitializeL(

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

				CDesC8Array* array = NULL;

				if(iSessionParams.iPoCAdhocSessionType)	

					{

					array = new (ELeave) CDesC8ArrayFlat(1);	

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

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

					}

				else

					{

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

					}

				}

			iSession = outSession;

			iOutSession = outSession;     

	   	}

	   else 

	   	{

		    // Create Outsession

		    CMceOutSession* outSession = CMceOutSession::NewL(

	        iEngine.MCEManager(), 

	        iProfile->Profile(),

	        recipient );

	    	CleanupStack::PushL(outSession);

		    if(iSessionType == EPoCSession)

				{

			 	FillPoCSessionData(outSession);

				}

			else if (iSessionType == ECustomSession)

				{

				FillCustomSessionData(outSession);

				}

			CleanupStack::Pop( outSession );

			if(iEngine.IsFCSession()) 

				{

				TRAP_IGNORE(iEngine.FloorControl().InitializeL(

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

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

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

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

				}

			iSession = outSession;

			iOutSession = outSession; 

	   	}

		    // Get identity

	    iId = iEngine.NextOutSessionId();

    	}

    }

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

// 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 ) );

		    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 ) );                              

		    break;

		case CMceSession::EEstablished:

			if(VideoDirection() != CMCETestUIEngineSession::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()

    {

    return *iOutSession;

    }

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

// CMCETestUIEngineOutSession::SessionParams

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

//

TBool CMCETestUIEngineOutSession::SessionParamsL(TSessionParams &aSessionParams,

									CMCETestUIEngineOutSession::TSessionType aSessionType)

	{

  	return iEngine.SessionParamsL( aSessionParams,aSessionType );

 	}

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

// CMCETestUIEngineOutSession::FillPoCSessionData

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

//

void CMCETestUIEngineOutSession::FillProfileRegistrar()

	{

	// trying to get profile registrar 

    TUriParser8 parser;

    const TDesC8& aor = iProfile->Aor();

    parser.Parse( aor ) ; 

    CUri8* uri8 = CUri8::NewLC( parser );

    const TDesC8& registrar =  uri8->Uri().Extract( EUriHost ) ;

    HBufC*registrar16 = HBufC16::NewLC( KRecipent().Length() + registrar.Length() );

    TPtr registrarPtr = registrar16->Des();

    registrarPtr.Copy( registrar );

    iSessionParams.iRecipentAddress.Append(KRecipent) ;

    iSessionParams.iRecipentAddress.Append(*registrar16)  ;

    CleanupStack::PopAndDestroy( registrar16 );

    registrar16 = NULL;

    CleanupStack::PopAndDestroy( uri8 );

    uri8 = NULL; 

    // profile registrar end .....

	}

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

// CMCETestUIEngineOutSession::FillPoCorigAddress

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

//

void CMCETestUIEngineOutSession::FillPoCOrigAddress()

	{

    if(iEngine.IsFCSession())

    	{

    	const TDesC8& aor = iProfile->Aor();

    	HBufC*aor16 = HBufC16::NewLC( aor.Length() );

    	TPtr aorPtr = aor16->Des();

    	aorPtr.Copy(aor);

    	iSessionParams.originator.Append(*aor16)  ;

	    CleanupStack::PopAndDestroy( aor16 );

	    aor16 = NULL;

	   	}

   	}

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

// CMCETestUIEngineOutSession::FillPoCSessionData

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

//

void CMCETestUIEngineOutSession::FillPoCSessionData(CMceOutSession* outSession)

	{

	iDirection = CMCETestUIEngineOutSession::ESendRecv;

	const TInt KStartLocalPort = 6688;

    const TInt AMRDefOfferPTime = 160;

    // Maximum ptime

    const TInt AMRDefOfferMaxPTime = 400;

    // Allowed bitrates

    const TInt AMRDefOfferAllowedBitrates = KMceAllowedAmrNbBitrate475 | 

								  KMceAllowedAmrNbBitrate515 | 

								  KMceAllowedAmrNbBitrate590;

    // Bitrate

    const TInt AMRDefOfferBitrate = KMceAmrNbBitrate515;

    // Codec mode

    const TInt AMRDefOfferCodingMode = EMceOctetAligned;

	 CMceAudioStream* audioOutStream = NULL;

	 	// audio in stream

	CMceAudioStream* audioStreamIn = CMceAudioStream::NewLC();

	TInt locPort( KStartLocalPort );

	locPort = locPort + ( 128 * 2 );

	audioStreamIn->SetLocalMediaPortL( locPort );

	CMceSpeakerSink* speakerSink = CMceSpeakerSink::NewLC();

	audioStreamIn->AddSinkL(speakerSink);

	CleanupStack::Pop();

	// TODO:

	CMceRtpSource* rtpSource = CMceRtpSource::NewLC( 10, 5, 1000 );

	audioStreamIn->SetSourceL(rtpSource);

	CleanupStack::Pop();	

	CMceAudioStream* audioStreamOut = CMceAudioStream::NewLC();

	CMceRtpSink* rtpSink = CMceRtpSink::NewL( ETrue );

	audioStreamOut->AddSinkL(rtpSink);

	CMceMicSource* micSource = CMceMicSource::NewLC();

	audioStreamOut->SetSourceL(micSource);

	CleanupStack::Pop();	

	audioStreamIn->BindL(audioStreamOut);

	CleanupStack::Pop(audioStreamOut);

	// floor control

	outSession->AddStreamL( audioStreamIn );

	CleanupStack::Pop(audioStreamIn);

	// 

	// TODO: Currently MMComms supports only the first codec of the stream

	//

	const RPointerArray<CMceAudioCodec>& coddecs =  audioStreamIn->Codecs();

	CMceAmrCodec* amrcodec = (CMceAmrCodec*)coddecs[0];

	const RPointerArray<CMceAudioCodec>& coddecsOut =  audioStreamOut->Codecs();

	CMceAmrCodec* amrcodecOut = (CMceAmrCodec*)coddecsOut[0];

	// set prioirity for uplink

	amrcodecOut->SetMMFPriorityL( KAudioPriorityPocAudioUplink );

    amrcodecOut->SetMMFPriorityPreferenceL( KAudioPrefPocAudioUplink );

	// set prioirity for downlink

	amrcodec->SetMMFPriorityL( KAudioPriorityPocAudioDownlink );

    amrcodec->SetMMFPriorityPreferenceL( KAudioPrefPocAudioDownlink );

	//

	// Set initial parameters for codec

	//

	// Allowed bitrates

	amrcodec->SetAllowedBitrates( AMRDefOfferAllowedBitrates );

	// Bitrate should be 5150

	amrcodec->SetBitrate( AMRDefOfferBitrate );

    // AMR narrow band, sampling rate 8000

	amrcodec->SetSamplingFreq( KMceAmrNbSamplingFreq );

	// Use bandwith effient coding

	amrcodec->SetCodecMode( AMRDefOfferCodingMode );

	// Default packet ratio is 8 AMR packets per one RTP packet

	// -> ptime = 8 * 20 = 160. Lower value is not good with GPRS bearer

	amrcodec->SetPTime(AMRDefOfferPTime );

	// Allowable maximum ptime, 400 should be OK

	amrcodec->SetMaxPTime( AMRDefOfferMaxPTime );

	// 106 seems to be common payload type

	amrcodec->SetPayloadType( 106 );

	// Disabled here due to audio server crash

	CMceRtpSink* rtpOutSink = (CMceRtpSink*) audioStreamOut->Sinks()[0];

	rtpOutSink->DisableL();

	}

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

// CMCETestUIEngineOutSession::FillCustomSessionData	

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

//

void CMCETestUIEngineOutSession::FillCustomSessionData(CMceOutSession* outSession)

	{

	// setmodifier for the session, by default preconditions are present, if no preconditions then setthis

	if( iSessionParams.iNoPrecondtion) 

		{

		outSession->SetModifierL(0,0);

		}

	switch (iSessionParams.index )

	    {

	    case 0: 

	        iDirection = CMCETestUIEngineOutSession::ESendRecv;

	        break;

	    case 1: 

	        iDirection = CMCETestUIEngineOutSession::ESendOnly;

	        break;

	    case 2: 

	        iDirection = CMCETestUIEngineOutSession::ERecvOnly;

	        break;

	    default:

	        iDirection = CMCETestUIEngineOutSession::ENotSpesified;

	        break;

	    }

	    CMceFileSource* fileSource = NULL;

	 	if ( iDirection != CMCETestUIEngineOutSession::ENotSpesified )

	    {

	    // Create outstream (== uplink)

	    CMceAudioStream* audioOutStream = NULL;

	    if ( iDirection == CMCETestUIEngineOutSession::ESendOnly ||  

	         iDirection == CMCETestUIEngineOutSession::ESendRecv )

	        {

	        audioOutStream = CMceAudioStream::NewLC();

	        CMceMicSource* mic = NULL;

			if(iSessionParams.sourceType)

				{

				fileSource = CMceFileSource::NewL(iEngine.MCEManager(), iSessionParams.sourceFile );

            	CleanupStack::PushL( fileSource );

            	audioOutStream->SetSourceL(fileSource);

            	CleanupStack::Pop();

				}

			else

				{

				mic = CMceMicSource::NewLC();

				audioOutStream->SetSourceL( mic );	

				CleanupStack::Pop( mic );

				}