/*

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

*

*/

#include "MCEConstants.h"

#include "TCmdGetStreamInfo.h"

#include "CTcMCEContext.h"

#include <MCEAudioStream.h>

#include <MCEVideoStream.h>

#include <MCERTPSource.h>

#include <MCEMicSource.h>

#include <MCECameraSource.h>

#include <MCERTPSink.h>

#include <MCESpeakerSink.h>

#include <MCEDisplaySink.h>

#include <mcefilesink.h>

#include <MCEAudioCodec.h>

#include <badesca.h>

#include "mcefilesource.h"

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

// TCmdGetStreamInfo::ExecuteL

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

//

void TCmdGetStreamInfo::ExecuteL()

	{	

	// ---------- Setup --------------------------------------------------------

	// Get stream 

	CMceSession* session= 

		reinterpret_cast<CMceSession*>(GetObjectForIdL(KSessionId, ETrue));	

	CDesC8Array* mediaStreams = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( mediaStreams );

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

	for (TInt streamIndex=0; streamIndex < streamPtrs.Count(); streamIndex++)

		{

		// Add to registry by reference and fetch name

		iContext.Registry().AddObjectL( *(streamPtrs[streamIndex]) );	

		TBuf8< KTcMaxObjectName > streamId = 

					iContext.Registry().ObjectNameL( streamPtrs[streamIndex] );	

		mediaStreams->AppendL( streamId );

		}

	// ---------- Execution ----------------------------------------------------

	// ---------- Response creation --------------------------------------------

	AddIdResponseL(KSessionId, session); // uses CleanupStack internally

	if ( mediaStreams->Count() > 0 )

		{

		AddArrayResponseL( KResponseStreams, *mediaStreams );	

		for (TInt streamIndex=0; streamIndex < streamPtrs.Count(); streamIndex++)

			{

			if ((streamPtrs[streamIndex])->Type()==KMceAudio)

				{

				CMceAudioStream* audioStream =reinterpret_cast<CMceAudioStream*>

						(iContext.Registry().ObjectPtrL( mediaStreams->MdcaPoint(streamIndex) ));

				//get the audio stream info

				GetAudioStreamInfo( audioStream );

				}

			else if ((streamPtrs[streamIndex])->Type()==KMceVideo)

				{

				CMceVideoStream* videoStream =reinterpret_cast<CMceVideoStream*>

						(iContext.Registry().ObjectPtrL( mediaStreams->MdcaPoint(streamIndex) ));

				//get the video stream info

				GetVideoStreamInfo( videoStream );

				}

			else

				{

				// Keep pc-lint happy

				}

			}

		CleanupStack::PopAndDestroy( mediaStreams );

		}

	else

		{

		CleanupStack::PopAndDestroy( mediaStreams );

		}

	}

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

// TCmdGetStreamInfo::AddSourceToResponse

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

//

void

TCmdGetStreamInfo::AddSourceToResponseL( const TDesC8& aParamNameForSourceId,

										 const TDesC8& aParamNameForSource,

										 CMceMediaStream& aStream )

	{

	CMceMediaSource* source = aStream.Source();

	iContext.Registry().AddObjectL( *source );

	TBuf8< KTcMaxObjectName > sourceId =

		iContext.Registry().ObjectNameL( source );

	AddTextResponseL( aParamNameForSourceId, sourceId );

	switch ( source->Type() )

		{

		case KMceRTPSource:

			{

			AddTextResponseL( aParamNameForSource, KValueSourceRTP );

			break;

			}

		case KMceMicSource:

			{

			AddTextResponseL( aParamNameForSource, KValueSourceMic );

			break;

			}	

		case KMceCameraSource:

			{

			AddTextResponseL( aParamNameForSource, KValueSourceCamera );

			break;	

			}		

		case KMceFileSource:

			{

			AddTextResponseL( aParamNameForSource, KValueSourceFile );

			break;	

			}

		default:

			{

			AddTextResponseL( aParamNameForSource, KValueSourceUnknown );

			break;	

			}

		}

	}

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

// TCmdGetStreamInfo::AddSinksToResponse

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

//

void TCmdGetStreamInfo::AddSinksToResponseL( const TDesC8& aParamNameForSinkIds,

                                             const TDesC8& aParamNameForSinks,

								             CMceMediaStream& aStream )

	{

	// Array for sink ids

	CDesC8Array* sinkIds = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( sinkIds );

	// Array for sink names

	CDesC8Array* sinks = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( sinks );

	const RPointerArray<CMceMediaSink>& sinkPtrs = aStream.Sinks();

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

		{

		// Id

		iContext.Registry().AddObjectL( *(sinkPtrs[i]) );	

		TPtrC8 sinkId = iContext.Registry().ObjectNameL( sinkPtrs[i] );

		sinkIds->AppendL( sinkId );

		// Name

		switch ( sinkPtrs[i]->Type() )

			{

			case KMceRTPSink:

				{

				sinks->AppendL( KValueSinkRTP );

				break;	

				}

			case KMceSpeakerSink:

				{

				sinks->AppendL( KValueSinkSpeaker );

				break;	

				}

			case KMceDisplaySink:

				{

				sinks->AppendL( KValueSinkDisplay );

				break;	

				}

			case KMceFileSink:

				{

				sinks->AppendL( KValueSinkFile );

				break;	

				}	

			default:

				{

				sinks->AppendL( KValueSinkUnknown );

				break;

				}

			}

		}

	if ( sinks->Count() )

		{	

		AddArrayResponseL( aParamNameForSinkIds, *sinkIds );

		AddArrayResponseL( aParamNameForSinks, *sinks );

		}

	CleanupStack::PopAndDestroy( sinks );

	CleanupStack::PopAndDestroy( sinkIds );	

	}

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

// TCmdGetStreamInfo::AddAudioCodecsToResponse

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

//

void TCmdGetStreamInfo::AddAudioCodecsToResponseL( const TDesC8& aName,

											  	   CMceAudioStream& aStream )

	{

	CDesC8Array* codecs = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( codecs );

	const RPointerArray<CMceAudioCodec>& codecPtrs = aStream.Codecs();

	for (TInt codecIndex = 0; codecIndex < codecPtrs.Count(); codecIndex++ )

		{		

		// Add codec to registry by reference and fetch name

		iContext.Registry().AddObjectL( *(codecPtrs[codecIndex]) );	

		TBuf8< KTcMaxObjectName > codecId = 

					iContext.Registry().ObjectNameL( codecPtrs[codecIndex] );	

		codecs->AppendL( codecId );

		}

	if ( codecs->Count() )

		{

		AddArrayResponseL( aName, *codecs );

		}

	CleanupStack::PopAndDestroy( codecs );	

	}

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

// TCmdGetStreamInfo::AddVideoCodecsToResponse

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

//

void TCmdGetStreamInfo::AddVideoCodecsToResponseL( const TDesC8& aName,

											  	   CMceVideoStream& aStream )

	{

	CDesC8Array* codecs = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( codecs );

	const RPointerArray<CMceVideoCodec>& codecPtrs = aStream.Codecs();

	for (TInt codecIndex = 0; codecIndex < codecPtrs.Count(); codecIndex++ )

		{

		// Add codec to registry by reference and fetch name

		iContext.Registry().AddObjectL( *(reinterpret_cast<CBase*>(codecPtrs[codecIndex]) ));

		TBuf8< KTcMaxObjectName > codecId = 

					iContext.Registry().ObjectNameL( codecPtrs[codecIndex] );	

		codecs->AppendL( codecId );

		}

	if ( codecs->Count() )

		{

		AddArrayResponseL( aName, *codecs );

		}

	CleanupStack::PopAndDestroy( codecs );	

	}	

void TCmdGetStreamInfo::GetAudioStreamInfo( CMceAudioStream* aAudioStream )

	{

	if (aAudioStream != NULL) 

		{

		AddTextResponseL( KResponseStreamType, KValueStreamTypeAudio );

		AddTextualStreamStateL( aAudioStream->IsEnabled(), EFalse );

		AddIntegerResponseL( KResponseLocalMediaPort, aAudioStream->LocalMediaPort() );

		AddSourceToResponseL( KResponseSourceId,

							  KResponseSource,

							  *aAudioStream );

		AddSinksToResponseL( KResponseSinkIds,

							 KResponseSinks,

							 *aAudioStream );

		AddAudioCodecsToResponseL( KResponseAudioCodecs, *aAudioStream );

		// Check boundStream

		if ( aAudioStream->BoundStream() )

			{

			// Add to registry by reference and fetch name

			iContext.Registry().AddObjectL( aAudioStream->BoundStreamL() );	

			TBuf8< KTcMaxObjectName > boundStreamId = 

				iContext.Registry().ObjectNameL( 

					&(aAudioStream->BoundStreamL()) );

			// Name is numeric, but adding is easier this way

			AddTextResponseL( KResponseBoundStream, boundStreamId );

			if ( aAudioStream->BoundStreamL().Type() == KMceAudio )

				{				

				CMceAudioStream* boundAudioStream = 

					static_cast<CMceAudioStream*>

						(&(aAudioStream->BoundStreamL()));

				AddTextResponseL( KResponseBoundStreamType, 

								  KValueStreamTypeAudio );	

				/*AddIntegerResponseL( KResponseBoundStreamState, 

									 boundAudioStream->State() );*/

				AddTextualStreamStateL( boundAudioStream->IsEnabled(), ETrue );

				AddIntegerResponseL( KResponseBoundLocalMediaPort, 

							 		 boundAudioStream->LocalMediaPort() );

				AddSourceToResponseL( KResponseBoundStreamSourceId, 

									  KResponseBoundStreamSource,

									  *boundAudioStream );

				AddSinksToResponseL( KResponseBoundStreamSinkIds,

				                     KResponseBoundStreamSinks, 

									 *boundAudioStream );

				AddAudioCodecsToResponseL( KResponseBoundStreamCodecs,

									  	   *boundAudioStream );

				}

			}

		}

	}

void TCmdGetStreamInfo::GetVideoStreamInfo( CMceVideoStream* aVideoStream )

	{

	if (aVideoStream != NULL) 

		{

		AddTextResponseL( KResponseStreamType, KValueStreamTypeVideo );

		AddTextualStreamStateL( aVideoStream->IsEnabled(), EFalse );

		AddIntegerResponseL( KResponseLocalMediaPort, aVideoStream->LocalMediaPort() );

		AddSourceToResponseL( KResponseSourceId,

							  KResponseSource,

							  *aVideoStream );

		AddSinksToResponseL( KResponseSinkIds, KResponseSinks, *aVideoStream );

		AddVideoCodecsToResponseL( KResponseVideoCodecs, *aVideoStream );

		// Check boundStream

		if ( aVideoStream->BoundStream() )

			{

			// Add to registry by reference and fetch name

			iContext.Registry().AddObjectL( aVideoStream->BoundStreamL() );	

			TBuf8< KTcMaxObjectName > boundStreamId = 

				iContext.Registry().ObjectNameL( 

					&(aVideoStream->BoundStreamL()) );

			// Name is numeric, but adding is easier this way

			AddTextResponseL( KResponseBoundStream, boundStreamId );

			if ( aVideoStream->BoundStreamL().Type() == KMceVideo )

				{	

				CMceVideoStream* boundVideoStream = 

					static_cast<CMceVideoStream*>

						(&(aVideoStream->BoundStreamL()));

				AddTextResponseL( KResponseBoundStreamType, 

								  KValueStreamTypeVideo );	

				AddTextualStreamStateL( boundVideoStream->IsEnabled(), ETrue );

				AddIntegerResponseL( KResponseBoundLocalMediaPort, 

									 boundVideoStream->LocalMediaPort() );

				AddSourceToResponseL( KResponseBoundStreamSourceId, 

									  KResponseBoundStreamSource,

									  *boundVideoStream );

				AddSinksToResponseL( KResponseBoundStreamSinkIds,

									 KResponseBoundStreamSinks, 

									 *boundVideoStream );

				AddVideoCodecsToResponseL( KResponseBoundStreamCodecs, 

										   *boundVideoStream );	 

				}

			}

		}

	}

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

// TCmdGetStreamInfo::Match

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

//	

TBool TCmdGetStreamInfo::Match( const TTcIdentifier& aId )

	{

	return TTcMceCommandBase::Match( aId, _L8("GetStreamInfo") );

	}

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

// TCmdGetStreamInfo::CreateL

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

//

TTcCommandBase* TCmdGetStreamInfo::CreateL( MTcTestContext& aContext )

	{

	return new( ELeave ) TCmdGetStreamInfo( aContext );

	}