/*

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

*

*/

#include "TMCETestUIEngineCmdDeleteAudioCodec.h"

#include "CMceTestUIEngineVideoCodec.h"

#include "CMceTestUIEngineCodec.h"

#include "cmcetestuiengineaudiostream.h"

#include <mceaudiostream.h>

#include <mceaudiocodec.h>

#include <mceamrcodec.h>

#include <mceg711codec.h>

#include <mceg729codec.h>

#include <mceilbccodec.h>

#include <mcedtmfcodec.h>

#include <mceredcodec.h>

#include <mcecncodec.h>

#include <mcedefs.h>

#include <mcemanager.h>

#include <mcecodec.h>

#include <mcevideocodec.h>

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

// TMCETestUIEngineCmdDeleteAudioCodec::TMCETestUIEngineCmdDeleteAudioCodec

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

//

TMCETestUIEngineCmdDeleteAudioCodec::TMCETestUIEngineCmdDeleteAudioCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdDeleteSession::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdDeleteAudioCodec::ExecuteL()

	{

	iEngine.DeleteAudioCodec( iCodec );

	}

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

// TMCETestUIEngineCmdDeleteSession::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdDeleteAudioCodec::Caption() const

	{

	return KCommandCaptionDeleteAudioCodec;

	}

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

// TMCETestUIEngineCmdDeleteVideoCodec::TMCETestUIEngineCmdDeleteVideoCodec

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

//

TMCETestUIEngineCmdDeleteVideoCodec::TMCETestUIEngineCmdDeleteVideoCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineVideoCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdDeleteVideoCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdDeleteVideoCodec::ExecuteL()

	{

	iEngine.DeleteVideoCodec( iCodec );

	}

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

// TMCETestUIEngineCmdDeleteSession::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdDeleteVideoCodec::Caption() const

	{

	return KCommandCaptionDeleteVideoCodec;

	}

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

// TMCETestUIEngineCmdAddCodec::TMCETestUIEngineCmdAddCodec

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

//

TMCETestUIEngineCmdAddCodec::TMCETestUIEngineCmdAddCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineAudioStream& aAudioStream  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iAudioStream( aAudioStream )

    {

    }

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

// TMCETestUIEngineCmdAddCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdAddCodec::ExecuteL()

	{

	const RPointerArray<const CMceAudioCodec>& codecs =  iEngine.MCEManager().SupportedAudioCodecs();

	TInt codecIndex = 0;

	iEngine.GetCodecTypeL( codecIndex  );

	switch(codecIndex)

		{

			case 0:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for AMR codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameAMR )  == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 1:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for PCMU codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNamePCMU ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 2:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for PCMU codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNamePCMA ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 3:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for G729 codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameG729 ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 4:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for iLBC codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameiLBC ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 5:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for iLBC codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameDtmf ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 6:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for iLBC codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameRed ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			case 7:

				{

				for( int i = 0; i < codecs.Count(); i++ )

			    {

			    // Search for iLBC codec 

				    if( codecs[i]->SdpName().Find( KMceSDPNameCn ) == KErrNone)

				        {

				    	iAudioStream.AudioStream().AddCodecL(codecs[i]->CloneL());

				    	}

			    }

				break;

				}

			default:

			   break;

		}

	 iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdAddCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdAddCodec::Caption() const

	{

	return KCommandCaptionAddCodec;

	}

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

// TMCETestUIEngineCmdEnableAudioCodec::TMCETestUIEngineCmdEnableAudioCodec

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

//

TMCETestUIEngineCmdEnableAudioCodec::TMCETestUIEngineCmdEnableAudioCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdEnableAudioCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdEnableAudioCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EEnabled);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdEnableAudioCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdEnableAudioCodec::Caption() const

	{

	return KCommandCaptionEnableVideoCodec;

	}

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

// TMCETestUIEngineCmdDisableAudioCodec::TMCETestUIEngineCmdDisableAudioCodec

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

//

TMCETestUIEngineCmdDisableAudioCodec::TMCETestUIEngineCmdDisableAudioCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdDisableAudioCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdDisableAudioCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EDisabled);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdDisableAudioCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdDisableAudioCodec::Caption() const

	{

	return KCommandCaptionDisableVideoCodec;

	}

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

// TMCETestUIEngineCmdStandByAudioCodec::TMCETestUIEngineCmdStandByAudioCodec

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

//

TMCETestUIEngineCmdStandByAudioCodec::TMCETestUIEngineCmdStandByAudioCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdStandByAudioCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdStandByAudioCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EStandby);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdStandByAudioCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdStandByAudioCodec::Caption() const

	{

	return KCommandCaptionStandByVideoCodec;

	}

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

// TMCETestUIEngineCmdEnableVideoCodec::TMCETestUIEngineCmdEnableVideoCodec

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

//

TMCETestUIEngineCmdEnableVideoCodec::TMCETestUIEngineCmdEnableVideoCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineVideoCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdEnableVideoCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdEnableVideoCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EEnabled);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdEnableVideoCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdEnableVideoCodec::Caption() const

	{

	return KCommandCaptionEnableVideoCodec;

	}

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

// TMCETestUIEngineCmdDisableVideoCodec::TMCETestUIEngineCmdDisableVideoCodec

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

//

TMCETestUIEngineCmdDisableVideoCodec::TMCETestUIEngineCmdDisableVideoCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineVideoCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdDisableVideoCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdDisableVideoCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EDisabled);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdDisableVideoCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdDisableVideoCodec::Caption() const

	{

	return KCommandCaptionDisableVideoCodec;

	}

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

// TMCETestUIEngineCmdStandByVideoCodec::TMCETestUIEngineCmdStandByVideoCodec

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

//

TMCETestUIEngineCmdStandByVideoCodec::TMCETestUIEngineCmdStandByVideoCodec( 

		            CMCETestUIEngine& aEngine,

		            CMCETestUIEngineVideoCodec& aCodec  )

    : TMCETestUIEngineCmdBase( aEngine ),

      iCodec( aCodec )

    {

    }

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

// TMCETestUIEngineCmdStandByVideoCodec::ExecuteL

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

//

EXPORT_C void TMCETestUIEngineCmdStandByVideoCodec::ExecuteL()

	{

	iCodec.Codec().SetStateL(CMceCodec::EStandby);

	iEngine.EngineStateChangedL();

	}

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

// TMCETestUIEngineCmdStandByVideoCodec::Caption

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

//

EXPORT_C const TDesC& TMCETestUIEngineCmdStandByVideoCodec::Caption() const

	{

	return KCommandCaptionStandByVideoCodec;

	}

// End of File