/*

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

*

*/

#include <bluetoothav.h>

//	User Includes

#include "T_AvdtpServiceCapabilityData.h"

#include "T_AvdtpHeaderCompressionCapabilitiesData.h"

/*@{*/

//Parameters

_LIT(KExpected,												"expected");

_LIT(KMedia,												"media");

_LIT(KRecovery,												"recovery");

_LIT(KBackChannel,											"backchannel");

//Commands

_LIT(KCmdnew,												"new");

_LIT(KCmdMedia,												"Media");

_LIT(KCmdRecovery,											"Recovery");

_LIT(KCmdBackChannel,										"BackChannel");

_LIT(KCmdSetCapabilities,									"SetCapabilities");

_LIT(KCmdDestructor,										"~"); 

//Log

_LIT(KLogMissingExpected,								"Missing expected '%S'");

_LIT(KLogError,											"Error=%d");

/*@}*/

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

// Construction/Destruction

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

CT_AvdtpHeaderCompressionCapabilitiesData* CT_AvdtpHeaderCompressionCapabilitiesData::NewL()

	{

	CT_AvdtpHeaderCompressionCapabilitiesData*	ret=new (ELeave) CT_AvdtpHeaderCompressionCapabilitiesData();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

CT_AvdtpHeaderCompressionCapabilitiesData::CT_AvdtpHeaderCompressionCapabilitiesData()

: iAvdtpHeaderCompressionCapabilities(NULL)

	{

	}

void CT_AvdtpHeaderCompressionCapabilitiesData::ConstructL()

	{

	}

TAvdtpServiceCapability* CT_AvdtpHeaderCompressionCapabilitiesData::GetAvdtpServiceCapability() const

	{

	return iAvdtpHeaderCompressionCapabilities;

	}

CT_AvdtpHeaderCompressionCapabilitiesData::~CT_AvdtpHeaderCompressionCapabilitiesData()

	{

	DestroyData();

	}

void CT_AvdtpHeaderCompressionCapabilitiesData::SetObjectL(TAny* aAny)

	{

	DestroyData();

	iAvdtpHeaderCompressionCapabilities = static_cast<TAvdtpHeaderCompressionCapabilities*> (aAny);

	}

void CT_AvdtpHeaderCompressionCapabilitiesData::DisownObjectL()

	{

	iAvdtpHeaderCompressionCapabilities = NULL;

	}

void CT_AvdtpHeaderCompressionCapabilitiesData::DestroyData()

	{

	delete iAvdtpHeaderCompressionCapabilities;

	iAvdtpHeaderCompressionCapabilities=NULL;	

	}

TBool CT_AvdtpHeaderCompressionCapabilitiesData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

	{

	TBool	ret = ETrue;

	if ( aCommand==KCmdnew )

		{

		DoCmdnewL();

		}

	else if ( aCommand==KCmdMedia )

		{

		DoCmdMedia(aSection);

		}

	else if ( aCommand==KCmdRecovery )

		{

		DoCmdRecovery(aSection);

		}

	else if ( aCommand==KCmdBackChannel )

		{

		DoCmdBackChannel(aSection);

		}

	else if ( aCommand==KCmdSetCapabilities )

		{

		DoCmdSetCapabilities(aSection);

		}

	else if ( aCommand==KCmdDestructor )

		{

		DestroyData();

		}

	else

		{

		ret=CT_AvdtpServiceCapabilityData::DoCommandL(aCommand, aSection, aAsyncErrorIndex);

		}

	return ret;

	}

/**

Test TAvdtpHeaderCompressionCapabilities()

*/

void CT_AvdtpHeaderCompressionCapabilitiesData::DoCmdnewL()

	{

	INFO_PRINTF1(_L("TAvdtpHeaderCompressionCapabilities Constructor Call"));

	DestroyData();

	TRAPD( err, iAvdtpHeaderCompressionCapabilities = new (ELeave) TAvdtpHeaderCompressionCapabilities());

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(KLogError, err);

		SetError(err);

		}

	}

/**

Test Media()

*/

void CT_AvdtpHeaderCompressionCapabilitiesData::DoCmdMedia(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("TAvdtpHeaderCompressionCapabilities Media() Call"));

	TBool media = iAvdtpHeaderCompressionCapabilities->Media();

	INFO_PRINTF2(_L("TAvdtpHeaderCompressionCapabilities Media result: actual = %d"), media);

	TBool expected = EFalse;

	if( GetBoolFromConfig(aSection, KExpected, expected) )

		{

		if( expected != media )

			{

			ERR_PRINTF1(_L("Media not as expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingExpected, &KExpected);

		SetBlockResult(EFail);		

		}

	}

/**

Test Recovery()

*/

void CT_AvdtpHeaderCompressionCapabilitiesData::DoCmdRecovery(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("TAvdtpHeaderCompressionCapabilities Recovery() Call"));

	TBool recovery = iAvdtpHeaderCompressionCapabilities->Recovery();

	INFO_PRINTF2(_L("TAvdtpHeaderCompressionCapabilities Recovery result: actual = %d"), recovery);

	TBool expected = EFalse;

	if( GetBoolFromConfig(aSection, KExpected, expected) )

		{

		if( expected != recovery )

			{

			ERR_PRINTF1(_L("Recovery not as expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingExpected, &KExpected);

		SetBlockResult(EFail);		

		}

	}

/**

Test BackChannel()

*/

void CT_AvdtpHeaderCompressionCapabilitiesData::DoCmdBackChannel(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("TAvdtpHeaderCompressionCapabilities BackChannel() Call"));

	TBool backChannel = iAvdtpHeaderCompressionCapabilities->BackChannel();

	INFO_PRINTF2(_L("TAvdtpHeaderCompressionCapabilities BackChannel result: actual = %d"), backChannel);

	TBool expected = EFalse;

	if( GetBoolFromConfig(aSection, KExpected, expected) )

		{

		if( expected != backChannel )

			{

			ERR_PRINTF1(_L("BackChannel not as expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingExpected, &KExpected);

		SetBlockResult(EFail);		

		}

	}

/**

Test SetCapabilities()

*/

void CT_AvdtpHeaderCompressionCapabilitiesData::DoCmdSetCapabilities(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("TAvdtpHeaderCompressionCapabilities SetCapabilities() Call"));

	TBool media = EFalse;

	if( GetBoolFromConfig(aSection, KMedia, media) )

		{

		TBool recovery = EFalse;

		if( GetBoolFromConfig(aSection, KRecovery, recovery) )

			{

			TBool backChannel = EFalse;

			if( GetBoolFromConfig(aSection, KBackChannel, backChannel) )

				{

				iAvdtpHeaderCompressionCapabilities->SetCapabilities(media, recovery, backChannel);

				}

			else

				{

				ERR_PRINTF2(_L("Missing parameter %S"), &KBackChannel);

				SetBlockResult(EFail);		

				}

			}

		else

			{

			ERR_PRINTF2(_L("Missing parameter %S"), &KRecovery);

			SetBlockResult(EFail);		

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter %S"), &KMedia);

		SetBlockResult(EFail);		

		}

	}