/*

* 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:    Implementation.

*

*/

// INCLUDES

#include "TMCETestUIEngineCmdUpdateSession.h"

#include "CMCETestUIQuestionSingleSelection.h"

#include "CMCETestUIQuestionDataQuery.h"

#include "CMCETestUIEngineSession.h"

#include "CMCETestUIEngineCodec.h"

#include "CMCETestUIEngineAudioStream.h"

#include "CMCETestUIEngineVideoCodec.h"

#include "CMCETestUIEngineVideoStream.h"

#include <MCESession.h>

#include <MceAudioStream.h>

#include <MCEAudioCodec.h>

#include <MCEFCMsgExchange.h>

#include <MceVideoStream.h>

#include <MCEVideoCodec.h>

#include <mcertpsource.h>

#include <mcemicsource.h>

#include <mcespeakersink.h>

#include <sipstrings.h> 

#include <sipstrconsts.h>

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

// TMCETestUIEngineCmdUpdateSession::TMCETestUIEngineCmdUpdateSession

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

//

TMCETestUIEngineCmdUpdateSession::TMCETestUIEngineCmdUpdateSession( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineSession& aSession )

    : TMCETestUIEngineCmdBase( aEngine ),

      iSession( aSession )

    {

    }

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

// TMCETestUIEngineCmdUpdateSession::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdUpdateSession::ExecuteL()

	{

	if(iEngine.iMultiCodecSupport == EFalse)

		{

		DeleteCodecs();	

		} // delete this if you want to delete all codecs manually

	iSession.Session().UpdateL();

	iEngine.EngineStateChangedL();    

	}

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

// TMCETestUIEngineCmdUpdateSession::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdUpdateSession::Caption() const

	{

	return KCommandCaptionUpdateSession;

	}

EXPORT_C void TMCETestUIEngineCmdUpdateSession:: DeleteCodecs()

	{

	const RPointerArray<CMCETestUIEngineAudioStream>& audioStreams = 

            iSession.AudioStreamsL();

         for ( TInt i = 0; i < audioStreams.Count(); ++i )

        	{

        	 RPointerArray<CMCETestUIEngineCodec>& codecs = 

            	audioStreams[i]->CodecsL();

            	TInt count = codecs.Count();

            //delete all codecs except first one	

         	for ( TInt j = count-1; j > 0; --j )

				{

				 audioStreams[i]->AudioStream().RemoveCodecL(codecs[j]->Codec());

		         delete codecs[j];

		         codecs.Remove( j );

		         codecs.Compress();

		         iEngine.EngineStateChangedL();

		        }

        	}

     const RPointerArray<CMCETestUIEngineVideoStream>& videoStreams = 

            iSession.VideoStreamsL();

         for ( TInt i = 0; i < videoStreams.Count(); ++i )

        	{

        	 RPointerArray<CMCETestUIEngineVideoCodec>& codecs = 

            	videoStreams[i]->CodecsL();

            	TInt count = codecs.Count();

            //delete all codecs except first one	

         	for ( TInt j = count-1; j > 0; --j )

				{

				 videoStreams[i]->VideoStream().RemoveCodecL(codecs[j]->Codec());

		         delete codecs[j];

		         codecs.Remove( j );

		         codecs.Compress();

		         iEngine.EngineStateChangedL();

		        }

        	}

	}

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

// TMCETestUIEngineCmdUpdateSessionWithValues::TMCETestUIEngineCmdUpdateSessionWithValues

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

//

TMCETestUIEngineCmdUpdateSessionWithValues::TMCETestUIEngineCmdUpdateSessionWithValues( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineSession& aSession )

    : TMCETestUIEngineCmdBase( aEngine ),

      iSession( aSession )

    {

    }

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

// TMCETestUIEngineCmdUpdateSessionWithValues::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdUpdateSessionWithValues::ExecuteL()

	{

	if(iEngine.iMultiCodecSupport == EFalse)

		{

		DeleteCodecs();	

		} // delete this if you want to delete all codecs manually

	if(iEngine.IsFCSession())// for PoC Session update , may be new update can be added for PoC

		{

	//	iEngine.FloorControl().InitializeL(iSession.Session(),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=1; poc_lock=0\r\n"));

		iEngine.FloorControl().UpdateL(iSession.Session(), array);	

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

		CleanupStack::PushL( sipHeaders );	//1

	//	sipHeaders->AppendL(_L8("Accept-Contact: *;+mckoppa"));					

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

		CleanupStack::PushL( contHeaders );							// 2

		// empty content type

		HBufC8* contentType = HBufC8::NewLC( 1 );					// 3

		HBufC8* sdpcontent = HBufC8::NewLC( 1 ); 					// 4

		// server - header

		sipHeaders->AppendL( (_L8("Server: PoC-client/OMA1.0 Nokia-S60/v1.0")) );

		// privacy - header

		sipHeaders->AppendL(_L8("Privacy: id;user;header"));

		// p-preferred identity header

						// 4

		sipHeaders->AppendL( (_L8("P-Preferred-Identity: <sip:someone@somewhere.com> ")) );

		iSession.Session().UpdateL( 36000, 

							  sipHeaders,

							  contentType,

							  sdpcontent,

							  contHeaders );

	    CleanupStack::Pop( sdpcontent );

	    CleanupStack::Pop( contentType );

	    CleanupStack::Pop( contHeaders );

	    CleanupStack::Pop( sipHeaders );	

		iEngine.EngineStateChangedL();    

		}

	else

		{

		TSessionEstablishValues sessionValues;

    	if(iEngine.SessionEstablishValues( sessionValues))

    	{

    	// change the values to the format needed by api 

    	CDesC8Array* headers;

    	if(sessionValues.headers.Compare(KNone))

    		{

    		CMCETestUIQuestionDataQuery* question = 

	    			CMCETestUIQuestionDataQuery::NewLC();

    		question->SetCaptionL( KUserQuestionInputRecipient );

			question->SetDefaultValueL(sessionValues.headers  );

			question->SetAnswerL( sessionValues.headers );

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

			CleanupStack::PopAndDestroy( question );

			headers = new (ELeave) CDesC8ArrayFlat( 1 );

			CleanupStack::PushL( headers );

			headers->AppendL( headersbuffer );

    		}

    	else

    		{

    		headers = new (ELeave) CDesC8ArrayFlat( 1 );

			CleanupStack::PushL( headers );

		//	headers->AppendL(_L8("Accept-Contact: *;+mckoppa"));

		//	headers->AppendL( KAcceptContactMCETestUI );	

    		}

			CleanupStack::Pop( headers );

			iSession.Session().SetServiceTypeL(sessionValues.iServiceType);

			iSession.Session().UpdateL(sessionValues.timeOut, headers, NULL, NULL, NULL );

			iEngine.EngineStateChangedL();

	       	}

		}

	}

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

// TMCETestUIEngineCmdUpdateSessionWithValues::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdUpdateSessionWithValues::Caption() const

	{

	return KUserQuestionOptionUpdateWithValues;

	}

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

// TMCETestUIEngineCmdUpdateSessionWithValues::DeleteCodecs

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

//

EXPORT_C void TMCETestUIEngineCmdUpdateSessionWithValues:: DeleteCodecs()

	{

	const RPointerArray<CMCETestUIEngineAudioStream>& audioStreams = 

            iSession.CurrentAudioStreams();

         for ( TInt i = 0; i < audioStreams.Count(); ++i )

        	{

        	 RPointerArray<CMCETestUIEngineCodec>& codecs = 

            	audioStreams[i]->CurrentCodecs();

            //delete all codecs except first one	

         	for ( TInt j = 1; j < codecs.Count(); ++j )

				{

				 audioStreams[i]->AudioStream().RemoveCodecL(codecs[j]->Codec());

		         delete codecs[j];

		         codecs.Remove( j );

		         codecs.Compress();

		        }

        	}

      const RPointerArray<CMCETestUIEngineVideoStream>& videoStreams = 

            iSession.VideoStreamsL();

         for ( TInt i = 0; i < videoStreams.Count(); ++i )

        	{

        	 RPointerArray<CMCETestUIEngineVideoCodec>& codecs = 

            	videoStreams[i]->CodecsL();

            	TInt count = codecs.Count();

            //delete all codecs except first one	

         	for ( TInt j = count-1; j > 0; --j )

				{

				 videoStreams[i]->VideoStream().RemoveCodecL(codecs[j]->Codec());

		         delete codecs[j];

		         codecs.Remove( j );

		         codecs.Compress();

		         iEngine.EngineStateChangedL();

		        }

        	}

	}

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

// TMCETestUIEngineCmdUpdateSession::TMCETestUIEngineCmdUpdateSession

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

//

TMCETestUIEngineCmdHoldCall::TMCETestUIEngineCmdHoldCall( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineSession& aSession )

    : TMCETestUIEngineCmdBase( aEngine ),

      iSession( aSession )

    {

    }

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

// TMCETestUIEngineCmdUpdateSession::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdHoldCall::ExecuteL()

	{

	const RPointerArray<CMceMediaStream>& streams = iSession.Session().Streams();

	CMceMediaStream& mainstream = *streams[0];

	CMceMediaStream& boundStream = mainstream.BoundStreamL();

    if( !iSession.iHold )

        {

        HandleLocalHoldingL( mainstream, boundStream );

        DisableAudioL();

        iSession.iHold = ETrue;

        }

    else

        {

        HandleLocalResumingL( mainstream, boundStream );

        iSession.iHold = EFalse;

        iSession.iHoldInProgress = ETrue;

        }

	iSession.Session().UpdateL();

	iEngine.EngineStateChangedL();    

	}

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

// CSVPHoldMediaHandler::HandleLocalHoldingL - copied from VoIP

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

//

EXPORT_C void TMCETestUIEngineCmdHoldCall::

HandleLocalHoldingL( CMceMediaStream& aMediaStream,

                     CMceMediaStream& aBoundStream )

    {

    // In case of local hold RTP source must be disabled

    if ( KMceRTPSource == aMediaStream.Source()->Type() )

        {

        aMediaStream.DisableL();

        }

    else if ( KMceRTPSource == aBoundStream.Source()->Type() )

        {

        aBoundStream.DisableL();

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CSVPHoldMediaHandler::DisableAudioL

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

//

EXPORT_C void TMCETestUIEngineCmdHoldCall::DisableAudioL()

    {

    // Disable speaker & microphone

    CMceSession* session = &iSession.Session();

    const RPointerArray< CMceMediaStream >& streams = session->Streams();

    TInt streamCount = streams.Count();

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

        {

        CMceMediaStream* mediaStream = streams[ i ];

        TMceMediaType mediaType = mediaStream->Type();

        if ( KMceAudio == mediaType )

            {

            CMceMediaStream& boundStream = mediaStream->BoundStreamL();

            DisableAudioStreamL( boundStream );

            DisableAudioStreamL( *mediaStream );

            }

        } 

    }

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

// CSVPHoldMediaHandler::DisableAudioStreamL

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

//

EXPORT_C void TMCETestUIEngineCmdHoldCall::DisableAudioStreamL( CMceMediaStream& aAudioStream )

    {

    if ( aAudioStream.Source() &&

         KMceMicSource == aAudioStream.Source()->Type() )

        {

        CMceMicSource* micSource = 

                    ( CMceMicSource* ) aAudioStream.Source();

        if ( micSource->IsEnabled() )

            {

            // mute speaker sink

            micSource->DisableL();

            }

        } 

     if ( aAudioStream.Sinks().Count()  )

        {

        const RPointerArray< CMceMediaSink >& sinks = 

            aAudioStream.Sinks();

        for ( TInt z = 0; z < sinks.Count(); z++ )

            {

            if ( sinks[ z ]->Type() == KMceSpeakerSink )

                {

                CMceSpeakerSink* speakerSink = 

                    ( CMceSpeakerSink* )  sinks[ z ];

                if ( speakerSink->IsEnabled() )

                    {

                    // mute speaker sink

                    speakerSink->DisableL();                    

                    }

                }

            } 

        }                              

    } 

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

// CSVPHoldMediaHandler::HandleLocalResumingL

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

//

EXPORT_C void TMCETestUIEngineCmdHoldCall::

HandleLocalResumingL( CMceMediaStream& aMediaStream,

                      CMceMediaStream& aBoundStream )

    {

    if ( !aBoundStream.IsEnabled() )

        {

        aBoundStream.EnableL();

        }

    if ( !aMediaStream.IsEnabled() )

        {

        aMediaStream.EnableL();

        }

    }

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

// TMCETestUIEngineCmdUpdateSession::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdHoldCall::Caption() const

	{

	return KCommandCaptionHoldSession;

	}

// End of File