/*

* 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 "T_HALData.h"

/*@{*/

_LIT(KDeviceId,								"deviceid");

_LIT(KHalEValue,							"halEValue");

_LIT(KValue,								"value");

_LIT(KExpected,								"expected");

_LIT(KCmdSet,								"Set");

_LIT(KCmdGet,								"Get");

_LIT(KLogEnumNotFound,						"Enum '%S' not found");

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

_LIT(KLogMissingParameter,					"Missing parameter '%S'");

_LIT(KLogActualValue,						"Actual Value '%d' 0x%x");

/*@}*/

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

// Construction/Destruction

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

CT_HALData::CT_HALData(const THalTableLookup* aTable)

:	CDataWrapperBase()

,	iTable(aTable)

,	iValue(-1)

	{

	}

CT_HALData::~CT_HALData()

/**

 * Public destructor

 */

	{

	}

TAny* CT_HALData::GetObject()

/**

 * Return a pointer to the object that the data wraps

 *

 * @return	pointer to the object that the data wraps

 */

	{

	return NULL;

	}

const CT_HALData::THalTableLookup* CT_HALData::LookUp(const TDesC& aValue)

	{

	const THalTableLookup*	ret=NULL;

	TInt					index=0;

	while ( (iTable[index].iHalFunctionSetPrepare!=NULL) &&

			(iTable[index].iHalFunctionGetValidation!=NULL) && (ret==NULL) )

		{

		if ( iTable[index].iHalString==aValue )

			{

			ret=&iTable[index];

			}

		else

			{

			++index;

			}

		}

	return ret;

	}

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

/**

 * Process a command read from the ini file

 *

 * @param aCommand			The command to process

 * @param aSection			The section in the ini containing data for the command

 * @param aAsyncErrorIndex	Command index for async calls to return errors to

 *

 * @return					ETrue if the command is processed

 *

 * @leave					System wide error

 */

	{

	TBool	ret=ETrue;

	TInt	err=KErrNone;

	if ( aCommand==KCmdSet )

		{

		err=DoCmdSet(aSection);

		}

	else if ( aCommand==KCmdGet)

		{

		err=DoCmdGet(aSection);

		}

	else

		{

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

		}

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(KLogError, err);

		SetError(err);

		}

	return ret;

	}

TInt CT_HALData::DoCmdSet(const TDesC& aSection)

	{

	TInt	err=KErrNone;

	//	Do we have a device id

	TInt	deviceId=0;

	TBool	hasDeviceId=GetIntFromConfig(aSection, KDeviceId(), deviceId);

	//	Get the HAL variable to set

	TPtrC	enumString;

	if ( GetStringFromConfig(aSection, KHalEValue(), enumString) )

		{

		const THalTableLookup*	entry=LookUp(enumString);

		if ( entry==NULL )

			{

			//	HAL variable not valid

			ERR_PRINTF2(KLogEnumNotFound, &enumString);

			SetBlockResult(EFail);

			}

		else

			{

			TInt	value=0;

			//	Read data from ini file for the value to set

			if ( entry->iHalFunctionSetPrepare(this, aSection, value) )

				{

				//	Set the value

				if ( hasDeviceId )

					{

					err=HAL::Set(deviceId, entry->iHalAttribute, value);

					}

				else

					{

					err=HAL::Set(entry->iHalAttribute, value);

					}

				if ( err==KErrNone )

					{

					//	Set was successful so store it locally

					entry->iHalFunctionStore(this, value);

					}

				}

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingParameter, &KHalEValue());

		SetBlockResult(EFail);

		}

	return err;

	}

TInt CT_HALData::DoCmdGet(const TDesC& aSection)

	{

	TInt	err=KErrNone;

	//	Do we have a device id

	TInt	deviceId=0;

	TBool	hasDeviceId=GetIntFromConfig(aSection, KDeviceId(), deviceId);

	//	Get the HAL variable to set

	TPtrC	enumString;

	if ( GetStringFromConfig(aSection, KHalEValue(), enumString) )

		{

		const THalTableLookup*	entry=LookUp(enumString);

		if ( entry==NULL )

			{

			//	HAL variable not valid

			ERR_PRINTF2(KLogEnumNotFound, &enumString);

			SetBlockResult(EFail);

			}

		else

			{

			//	HAL::Get testing works within a range (needed if we request the full palette)

			//	Get the range of values to get

			TInt	valueStart=0;

			TInt	valueEnd=0;

			if ( entry->iHalFunctionGetPrepare(this, aSection, valueStart, valueEnd) )

				{

				for ( iValue=valueStart; (iValue<=valueEnd) && (err==KErrNone); ++iValue )

					{

					//	Get the value

					TInt	value=iValue;

					if ( hasDeviceId )

						{

						err=HAL::Get(deviceId, entry->iHalAttribute, value);

						}

					else

						{

						err=HAL::Get(entry->iHalAttribute, value);

						}

					if ( err==KErrNone )

						{

						//	Get was successful validate the returned value and store it locally

						INFO_PRINTF3(KLogActualValue, value, value);

						entry->iHalFunctionGetValidation(this, aSection, value, entry->iHalForceValidation);

						entry->iHalFunctionStore(this, value);

						}

					}

				}

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingParameter, &KHalEValue());

		SetBlockResult(EFail);

		}

	return err;

	}

//	Prepare the value we are setting as a TInt

TBool CT_HALData::SetPrepareInt(CDataWrapperBase* aThis, const TDesC& aSection, TInt& aValue)

	{

	TBool	ret=aThis->GetIntFromConfig(aSection, KValue(), aValue);

	if ( !ret )

		{

		aThis->ERR_PRINTF2(KLogMissingParameter, &KValue());

		aThis->SetBlockResult(EFail);

		}

	return ret;

	}

//	Prepare the value we are setting as a TUint

TBool CT_HALData::SetPrepareUint(CDataWrapperBase* aThis, const TDesC& aSection, TInt& aValue)

	{

	TUint	uint=aValue;

	TBool	ret=aThis->GetUintFromConfig(aSection, KValue(), uint);

	if ( !ret )

		{

		aThis->ERR_PRINTF2(KLogMissingParameter, &KValue());

		aThis->SetBlockResult(EFail);

		}

	aValue=uint;

	return ret;

	}

//	Validate the returned value from a HAL::Get as a TBool

void CT_HALData::GetValidationBool(CDataWrapperBase* aThis, const TDesC& aSection, TInt aValue, TBool aForceValidation)

	{

	TBool	expectedValue;

	TBool	ret=aThis->GetBoolFromConfig(aSection, KExpected(), expectedValue);

	if ( !ret )

		{

		if ( aForceValidation )

			{

			aThis->ERR_PRINTF2(KLogMissingParameter, &KExpected());

			aThis->SetBlockResult(EFail);

			}

		}

	else

		{

		if ( aValue!=expectedValue )

			{

			aThis->SetBlockResult(EFail);

			aThis->ERR_PRINTF3(_L("Retrived Value(%d) != expectedValue(%d)"), aValue, expectedValue);

			}

		}

	}

//	Validate the returned value from a HAL::Get as a TInt

void CT_HALData::GetValidationInt(CDataWrapperBase* aThis, const TDesC& aSection, TInt aValue, TBool aForceValidation)

	{

	TInt	expectedValue;

	TBool	ret=aThis->GetIntFromConfig(aSection, KExpected(), expectedValue);

	if ( !ret )

		{

		if ( aForceValidation )

			{

			aThis->ERR_PRINTF2(KLogMissingParameter, &KExpected());

			aThis->SetBlockResult(EFail);

			}

		}

	else

		{

		if ( aValue!=expectedValue )

			{

			aThis->SetBlockResult(EFail);

			aThis->ERR_PRINTF3(_L("Retrived Value(%d) != expectedValue(%d)"), aValue, expectedValue);

			}

		}

	}

//	Validate the returned value from a HAL::Get as a TUint

void CT_HALData::GetValidationUint(CDataWrapperBase* aThis, const TDesC& aSection, TInt aValue, TBool aForceValidation)

	{

	TUint	expectedValue;

	TBool	ret=aThis->GetUintFromConfig(aSection, KExpected(), expectedValue);

	if ( !ret )

		{

		if ( aForceValidation )

			{

			aThis->ERR_PRINTF2(KLogMissingParameter, &KExpected());

			aThis->SetBlockResult(EFail);

			}

		}

	else

		{

		if ( (TUint)aValue!=expectedValue )

			{

			aThis->SetBlockResult(EFail);

			aThis->ERR_PRINTF3(_L("Retrived Value(%d) != expectedValue(%d)"), aValue, expectedValue);

			}

		}

	}