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

/*@{*/
//Parameters
_LIT(KAuthentication,										"authentication");
_LIT(KAuthorisation,										"authorisation");
_LIT(KEncryption,											"encryption");
_LIT(KDenied,												"denied");
_LIT(KPasskeyMinLength,										"passkeyminlength");
_LIT(KExpected, 											"expected");

//Commands
_LIT(KCmdTBTAccessRequirements,								"TBTAccessRequirements");
_LIT(KCmdSetAuthentication,									"SetAuthentication");
_LIT(KCmdSetAuthorisation,									"SetAuthorisation");
_LIT(KCmdSetEncryption,										"SetEncryption");
_LIT(KCmdSetDenied,											"SetDenied");
_LIT(KCmdSetPasskeyMinLength,								"SetPasskeyMinLength");
_LIT(KCmdAuthenticationRequired,							"AuthenticationRequired");
_LIT(KCmdAuthorisationRequired,								"AuthorisationRequired");
_LIT(KCmdEncryptionRequired,								"EncryptionRequired");
_LIT(KCmdDenied,											"Denied");
_LIT(KCmdPasskeyMinLength,									"PasskeyMinLength");

//	Logging
_LIT(KLogMissingParameter,			"Missing parameter '%S'");
/*@}*/

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CT_BTAccessRequirementsData* CT_BTAccessRequirementsData::NewL()
	{
	CT_BTAccessRequirementsData*	ret=new (ELeave) CT_BTAccessRequirementsData();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

CT_BTAccessRequirementsData::CT_BTAccessRequirementsData()
:	iData(NULL)
	{
	}

void CT_BTAccessRequirementsData::ConstructL()
	{
	}

CT_BTAccessRequirementsData::~CT_BTAccessRequirementsData()
	{
	DestroyData();
	}

//	Service methods
TAny* CT_BTAccessRequirementsData::GetObject()
	{
	return iData;
	}

void CT_BTAccessRequirementsData::SetObjectL(TAny* aAny)
	{
	//called when loading up persistent data
	DestroyData();
	iData = static_cast<TBTAccessRequirements*> (aAny);
	}


void CT_BTAccessRequirementsData::DisownObjectL()
	{
	iData=NULL;
	}

void CT_BTAccessRequirementsData::DestroyData()
	{
	delete iData;
	iData=NULL;	
	}

inline TCleanupOperation CT_BTAccessRequirementsData::CleanupOperation()
	{
	return CleanupOperation;
	}

void CT_BTAccessRequirementsData::CleanupOperation(TAny* aAny)
	{
	TBTAccessRequirements* arg=static_cast<TBTAccessRequirements*>(aAny);
	delete arg;
	}

TBool CT_BTAccessRequirementsData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)
	{
	TBool	ret = ETrue;
	if ( aCommand==KCmdTBTAccessRequirements )
		{
		DoCmdTBTAccessRequirements();
		}
	else if ( aCommand==KCmdSetAuthentication )
		{
		DoCmdSetAuthentication(aSection);
		}
	else if ( aCommand==KCmdSetAuthorisation )
		{
		DoCmdSetAuthorisation(aSection);
		}
	else if ( aCommand==KCmdSetEncryption )
		{
		DoCmdSetEncryption(aSection);
		}
	else if ( aCommand==KCmdSetDenied )
		{
		DoCmdSetDenied(aSection);
		}
	else if ( aCommand==KCmdSetPasskeyMinLength )
		{
		DoCmdSetPasskeyMinLength(aSection);
		}
	else if ( aCommand==KCmdAuthenticationRequired )
		{
		DoCmdAuthenticationRequired(aSection);
		}
	else if ( aCommand==KCmdAuthorisationRequired )
		{
		DoCmdAuthorisationRequired(aSection);
		}
	else if ( aCommand==KCmdEncryptionRequired )
		{
		DoCmdEncryptionRequired(aSection);
		}
	else if ( aCommand==KCmdDenied )
		{
		DoCmdDenied(aSection);
		}
	else if ( aCommand==KCmdPasskeyMinLength )
		{
		DoCmdPasskeyMinLength(aSection);
		}
	else
		{
		ret=EFalse;
		}

	return ret;
	}


/**
Test TBTAccessRequirements()
*/
void CT_BTAccessRequirementsData::DoCmdTBTAccessRequirements()
	{
	INFO_PRINTF1(_L("TBTAccessRequirements Constructor Call"));
	DestroyData();
	iData = new (ELeave) TBTAccessRequirements();
	}


/**
Test SetAuthentication()
*/
void CT_BTAccessRequirementsData::DoCmdSetAuthentication(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements SetAuthentication Call"));

	TBool	authentication = EFalse;
	if(GetBoolFromConfig(aSection, KAuthentication(), authentication) )
		{
		iData->SetAuthentication(authentication);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KAuthentication());
		SetBlockResult(EFail);
		}
	}


/**
Test SetAuthorisation()
*/
void CT_BTAccessRequirementsData::DoCmdSetAuthorisation(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements SetAuthorisation Call"));

	TBool	authorisation = EFalse;
	if(GetBoolFromConfig(aSection, KAuthorisation(), authorisation) )
		{
		iData->SetAuthorisation(authorisation);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KAuthorisation());
		SetBlockResult(EFail);
		}
	}


/**
Test SetEncryption()
*/
void CT_BTAccessRequirementsData::DoCmdSetEncryption(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements SetEncryption Call"));

	TBool	encryption = EFalse;
	if(GetBoolFromConfig(aSection, KEncryption(), encryption) )
		{
		iData->SetEncryption(encryption);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KEncryption());
		SetBlockResult(EFail);
		}
	}


/**
Test SetDenied()
*/
void CT_BTAccessRequirementsData::DoCmdSetDenied(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements SetDenied Call"));

	TBool	denied = EFalse;
	if(GetBoolFromConfig(aSection, KDenied(), denied) )
		{
		iData->SetDenied(denied);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KDenied());
		SetBlockResult(EFail);
		}
	}


/**
Test SetPasskeyMinLength()
*/
void CT_BTAccessRequirementsData::DoCmdSetPasskeyMinLength(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements SetPasskeyMinLength Call"));

	TInt	passkeyMinLength = EFalse;
	if(GetIntFromConfig(aSection, KPasskeyMinLength(), passkeyMinLength) )
		{
		TInt result = iData->SetPasskeyMinLength(passkeyMinLength);
		if(result != KErrNone)
			{
			ERR_PRINTF2(_L("**** TBTAccessRequirements SetPasskeyMinLength failed with error %d"), result);
			SetError(result);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KPasskeyMinLength());
		SetBlockResult(EFail);
		}
	}


/**
Test AuthenticationRequired()
*/
void CT_BTAccessRequirementsData::DoCmdAuthenticationRequired(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements AuthenticationRequired Call"));
	
	TBool authentification = iData->AuthenticationRequired();
	INFO_PRINTF2(_L("TBTAccessRequirements AuthenticationRequired result: actual = %d"), authentification);
	
	TBool	expected = EFalse;
	if(GetBoolFromConfig(aSection, KExpected(), expected) )
		{
		if( expected != authentification )
			{
			ERR_PRINTF1(_L("AuthenticationRequired not as expected!"));
			SetBlockResult(EFail);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KExpected());
		SetBlockResult(EFail);
		}
	}


/**
Test AuthorisationRequired()
*/
void CT_BTAccessRequirementsData::DoCmdAuthorisationRequired(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements AuthorisationRequired Call"));
	
	TBool authorisation = iData->AuthorisationRequired();
	INFO_PRINTF2(_L("TBTAccessRequirements AuthorisationRequired result: actual = %d"), authorisation);
	
	TBool	expected = EFalse;
	if(GetBoolFromConfig(aSection, KExpected(), expected) )
		{
		if( expected != authorisation )
			{
			ERR_PRINTF1(_L("AuthorisationRequired not as expected!"));
			SetBlockResult(EFail);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KExpected());
		SetBlockResult(EFail);
		}
	}


/**
Test EncryptionRequired()
*/
void CT_BTAccessRequirementsData::DoCmdEncryptionRequired(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements EncryptionRequired Call"));
	
	TBool encryption = iData->EncryptionRequired();
	INFO_PRINTF2(_L("TBTAccessRequirements EncryptionRequired result: actual = %d"), encryption);
	
	TBool	expected = EFalse;
	if(GetBoolFromConfig(aSection, KExpected(), expected))
		{
		if( expected != encryption )
			{
			ERR_PRINTF1(_L("EncryptionRequired not as expected!"));
			SetBlockResult(EFail);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KExpected());
		SetBlockResult(EFail);
		}
	}


/**
Test Denied()
*/
void CT_BTAccessRequirementsData::DoCmdDenied(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements Denied Call"));
	
	TBool denied = iData->Denied();
	INFO_PRINTF2(_L("TBTAccessRequirements Denied result: actual = %d"), denied);
	
	TBool	expected = EFalse;
	if(GetBoolFromConfig(aSection, KExpected(), expected) )
		{
		if( expected != denied )
			{
			ERR_PRINTF1(_L("Denied not as expected!"));
			SetBlockResult(EFail);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KExpected());
		SetBlockResult(EFail);
		}
	}


/**
Test PasskeyMinLength()
*/
void CT_BTAccessRequirementsData::DoCmdPasskeyMinLength(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTAccessRequirements PasskeyMinLength Call"));
	
	TUint passkeyMinLength = iData->PasskeyMinLength();
	INFO_PRINTF2(_L("TBTAccessRequirements PasskeyMinLength result: actual = %d"), passkeyMinLength);
	
	TInt	expected = EFalse;
	if(GetIntFromConfig(aSection, KExpected(), expected) )
		{
		if( expected != passkeyMinLength )
			{
			ERR_PRINTF1(_L("PasskeyMinLength not as expected!"));
			SetBlockResult(EFail);
			}
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KExpected());
		SetBlockResult(EFail);
		}
	}