/*

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

#include "T_ImplementationInformationData.h"

#include "TestEComInterface.h"

/*@{*/

///	Parameters

_LIT(KUid,							"uid");

_LIT(KResolver,						"resolver");

_LIT(KExpectedResult,				"expected");

_LIT(KResolverUid,					"resolver_uid");

_LIT(KOffset,						"offset");

_LIT(KInteger,						"integer");

_LIT(KDescriptor,					"descriptor");

_LIT(KEmpty,						"empty");

_LIT(KSaveTo,						"saveto");

_LIT(KSaveIndex,					"saveindex");

///	REComSession

_LIT(KCmdOpenL,		 				"OpenL");

_LIT(KCmdClose,					 	"Close");

_LIT(KCmdFinalClose,				"FinalClose");

_LIT(KCmdNotifyOnChange,			"NotifyOnChange");

_LIT(KCmdCancelNotifyOnChange,		"CancelNotifyOnChange");

_LIT(KCmdListImplementationsL,		"ListImplementationsL");

_LIT(KCmdCreateImplementationL,		"CreateImplementationL");

_LIT(KCmdDestroyedImplementation,	"DestroyedImplementation");

_LIT(KCmdClean,						"~");

_LIT(KEmptyString,					"");

_LIT(KDefault,						"default");

/*@}*/

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

// Construction/Destruction

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

/**

 * Two phase constructor

 */

CT_EComSessionData* CT_EComSessionData::NewL()

	{

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

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

/**

 * Constructor. First phase construction

 */

CT_EComSessionData::CT_EComSessionData()

:	iActiveNotifyOnChange(NULL)

,	iImplementationInterface(NULL)

	{

	iInitParams.iInteger=0;

	iInitParams.iDescriptor=&iInterfaceDesc;

	}

/**

 * Second phase construction

 */

void CT_EComSessionData::ConstructL()

	{

	iInterfaceDesc=KEmptyString;

	iDTorKey=TUid::Uid(0);

	iActiveNotifyOnChange=CActiveCallback::NewL(*this);

	}

/**

 * Public destructor

 */

CT_EComSessionData::~CT_EComSessionData()

	{

	DestroyData();

	iInfoArray.ResetAndDestroy();

	iInfoArray.Close();

	delete iActiveNotifyOnChange;

	iActiveNotifyOnChange=NULL;

	}

TAny* CT_EComSessionData::GetObject()

/**

 * Return a pointer to the object that the data wraps

 *

 * @return	Pointer to the object that the data wraps

 */

	{

	return &iSession;

	}

void CT_EComSessionData::DestroyData()

	{

	if (iImplementationInterface)

		{

		delete static_cast<CBase*>(iImplementationInterface);

		iImplementationInterface=NULL;

		};

	}

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

// Read data from INI file

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

void CT_EComSessionData::GetUid(const TDesC& aSection, TUid& aUid)

	{

	TInt	uidValue=0;

	GetHexFromConfig(aSection, KUid(), uidValue );

	aUid = TUid::Uid(uidValue);

	}

TBool CT_EComSessionData::GetResolver(const TDesC& aSection, TPtrC& aResolver)

	{

	return GetStringFromConfig(aSection, KResolver(), aResolver);

	}

TBool CT_EComSessionData::GetResolverUid(const TDesC& aSection, TUid& aUid)

	{

	TInt	uidValue=0;

	TBool	ret=GetHexFromConfig(aSection, KResolverUid(), uidValue );

	aUid = TUid::Uid(uidValue);

	return ret;

	}

TBool CT_EComSessionData::GetEmpty(const TDesC& aSection, TBool& aEmpty)

	{

	aEmpty = EFalse;

	return GetBoolFromConfig(aSection, KEmpty(), aEmpty );

	}

TBool CT_EComSessionData::GetExpectedResult(const TDesC& aSection, TInt& aExpectedResult)

	{

	aExpectedResult = 0;

	return GetIntFromConfig(aSection, KExpectedResult(), aExpectedResult );

	}

TBool CT_EComSessionData::GetOffset(const TDesC& aSection, TInt& aOffset)

	{

	aOffset=_FOFF(CTestEComInterface, iDtor_ID_Key);

	TPtrC	offset;

	TBool	ret=GetStringFromConfig(aSection, KOffset(), offset);

	if ( ret )

		{

		if ( offset == KDefault )

			{

			INFO_PRINTF2(_L("Default offset %d"), aOffset);

			}

		else

			{

			ret=GetIntFromConfig(aSection, KOffset(), aOffset);

			}

		}

	return ret;

	}

TBool CT_EComSessionData::GetDescriptor(const TDesC& aSection, TPtrC& aDescriptor)

	{

	aDescriptor.Set(KEmptyString);

	return GetStringFromConfig(aSection, KDescriptor(), aDescriptor );

	}

TBool CT_EComSessionData::GetInteger(const TDesC& aSection, TInt& aInt)

	{

	return GetIntFromConfig(aSection, KInteger(), aInt );

	}

TBool CT_EComSessionData::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

 * @pre						N/A

 * @post					N/A

 *

 * @leave					System wide error

 */

	{

	TBool	retVal=ETrue;

	if ( aCommand==KCmdOpenL )

		{

		DoCmdOpenL();

		}

	else if ( aCommand==KCmdClose )

		{

		DoCmdClose();

		}

	else if ( aCommand==KCmdFinalClose )

		{

		DoCmdFinalClose();

		}

	else if ( aCommand==KCmdNotifyOnChange )

		{

		DoCmdNotifyOnChange(aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdCancelNotifyOnChange )

		{

		DoCmdCancelNotifyOnChange();

		}

	else if ( aCommand==KCmdListImplementationsL )

		{

		DoCmdListImplementationsL(aSection);

		}

	else if ( aCommand==KCmdCreateImplementationL )

		{

		DoCmdCreateImplementationL(aSection);

		}

	else if ( aCommand==KCmdDestroyedImplementation )

		{

		DoCmdDestroyedImplementation(aSection);

		}

	else if ( aCommand==KCmdClean )

		{

		DestroyData();

		}

	else

		{

		retVal=EFalse;

		}

	return retVal;

	}

void CT_EComSessionData::DoCmdOpenL()

	{

	INFO_PRINTF1(_L("OpenL Call"));

	TRAPD ( err, iSession = REComSession::OpenL() );

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("OpenL Error %d"), err);

		SetError(err);

		}

	else

		{

		INFO_PRINTF1(_L("Session opened"));

		}

	}

void CT_EComSessionData::DoCmdClose()

	{

	INFO_PRINTF1(_L("Close"));

	iSession.Close();

	}

void CT_EComSessionData::DoCmdFinalClose()

	{

	INFO_PRINTF1(_L("Final Close"));

	REComSession::FinalClose();

	}

void CT_EComSessionData::DoCmdNotifyOnChange(const TInt aIndex)

	{

	INFO_PRINTF1(_L("NotifyOnChange"));

	iSession.NotifyOnChange(iActiveNotifyOnChange->iStatus);

	iActiveNotifyOnChange->Activate(aIndex);

   	IncOutstanding();

	}

void CT_EComSessionData::DoCmdCancelNotifyOnChange()

	{

	INFO_PRINTF1(_L("CancelNotifyOnChange"));

	iSession.CancelNotifyOnChange(iActiveNotifyOnChange->iStatus);

	}

// Found defects:

// 1. ListImplementationsL with impossible aResolutionParameters argument don't leave

//    Status: possible defect

void CT_EComSessionData::DoCmdListImplementationsL(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Getting Implementnation List"));

	TUid	impUid;

	GetUid(aSection, impUid);

	TUid	resolverUid;

	TBool	hasResolverUid=GetResolverUid(aSection, resolverUid);

	TInt	err = KErrNone;

	TPtrC	resolver;

	TBool	hasResolver=GetResolver(aSection, resolver);

	if ( hasResolver )

		{

		TEComResolverParams*	resolverParams=static_cast<TEComResolverParams*>(GetDataObjectL(resolver));

		if ( hasResolverUid )

			{

			INFO_PRINTF1(_L("Getting Implementnation List(3) by Uid, ResolverParams as a filter params && Resolver Uid as a filter"));

			TRAP(err, REComSession::ListImplementationsL(impUid, *resolverParams, resolverUid, iInfoArray));

			}

		else

			{

			INFO_PRINTF1(_L("Getting Implementnation List(1) by Uid && ResolverParams as a filter"));

			TRAP(err, REComSession::ListImplementationsL(impUid, *resolverParams, iInfoArray));

			}

		}

	else

		{

		INFO_PRINTF1(_L("Getting Implementnation List(2) by Uid"));

		TRAP(err, REComSession::ListImplementationsL(impUid, iInfoArray));

		}

	if ( err==KErrNone )

		{

		//	Check to see if we the data object has to be set in a CT_ImplementationInformationData

		TPtrC	saveTo;

		if ( GetStringFromConfig(aSection, KSaveTo(), saveTo) )

			{

			TInt	index=0;

			GetIntFromConfig(aSection, KSaveIndex(), index);

			CDataWrapper*	wrapper=static_cast<CDataWrapper*>(GetDataWrapperL(saveTo));

			wrapper->SetObjectL(iInfoArray[index]);

			}

		}

	if( err != KErrNone )

		{

		ERR_PRINTF2(_L("Failed to get implementation list with error %d"), err);

		SetError(err);

		}

	else

		{

		TInt	expectedResult;

		if ( GetExpectedResult(aSection, expectedResult) )

			{

			if (iInfoArray.Count() != expectedResult)

				{

				ERR_PRINTF3(_L("List retrieved. Found %d imlementations, expected %d"),

				iInfoArray.Count(), expectedResult );

				SetBlockResult(EFail);

				}

			}

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

			{

			const TDesC8&	name8=iInfoArray[i]->DataType();

			TBuf<KMaxTestExecuteCommandLength>	name16;

			name16.Copy(name8);

			INFO_PRINTF3(_L("Implementation UID %d: - \"%S\""), iInfoArray[i]->ImplementationUid().iUid, &(iInfoArray[i]->DisplayName()));

			INFO_PRINTF2(_L("Data Type is \"%S\""), &name16);

			};

		}

	}

// Found defects:

// 1. CreateImplementationL with any aKeyOffset argument - aKeyOffset can have any value (-1, 0, 10000, ...)

//    but CreateImplementationL returns no error and generates memory leak.

//    Status: possible defects

// 2. CreateImplementationL with impossible aResolutionParameters argument - returns KErrnotFound, but in documentation

//    CreateImplementationL levaes only with KErrNoMemory, KErrNotConnected, KErrArgument or KErrPermissionDenied error

//    Status: documentation  defect

void CT_EComSessionData::DoCmdCreateImplementationL(const TDesC& aSection)

	{

	DestroyData();

	TUid	impUid;

	GetUid(aSection,impUid);

	TInt	offset;

	TBool	hasOffset=GetOffset(aSection,offset);

	TUid	resolverUid;

	TBool	hasResolverUid=GetResolverUid(aSection,	resolverUid);

	TBool	hasIntegerValue=GetInteger(aSection, iInitParams.iInteger);

	TBool	emptyArgs;

	TBool	hasEmptyArgs=GetEmpty(aSection, emptyArgs);

	TBool	hasInitParams=hasIntegerValue || hasEmptyArgs;

	TAny*	initParamsPtr=NULL;

	if (hasInitParams)

		{

		if (!emptyArgs)

			{

			initParamsPtr=&iInitParams;

			}

		}

	TInt	err = KErrNone;

	TBool	getKeyFromOffset=EFalse;

	TPtrC	resolver;

	if ( GetResolver(aSection, resolver) )

		{

		TEComResolverParams*	resolverParams=static_cast<TEComResolverParams*>(GetDataObjectL(resolver));

		if (hasResolverUid && hasInitParams && hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(12) by Interface Uid,  Offset, Init Params, ResolverParams as a filter params && Resolver Uid as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset, initParamsPtr, *resolverParams, resolverUid));

			getKeyFromOffset=(err==KErrNone);

			}

		else if (hasResolverUid && hasInitParams)

			{

			INFO_PRINTF1(_L("Creating Implementnation(11) by Interface Uid,  Init Params, ResolverParams as a filter params && Resolver Uid as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey, initParamsPtr, *resolverParams, resolverUid));

			}

		else if (hasResolverUid && hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(10) by Interface Uid, Offset, ResolverParams as a filter params && Resolver Uid as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset, *resolverParams, resolverUid));

			getKeyFromOffset=(err==KErrNone);

			}

		else if (hasResolverUid)

			{

			INFO_PRINTF1(_L("Creating Implementnation(9) by Interface Uid, ResolverParams as a filter params && Resolver Uid as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey, *resolverParams, resolverUid));

			}

		else if (hasInitParams && hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(8) by Interface Uid, Offset, Init Params && Resolver Parameters as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset, initParamsPtr, *resolverParams));

			getKeyFromOffset=(err==KErrNone);

			}

		else if (hasInitParams)

			{

			INFO_PRINTF1(_L("Creating Implementnation(7) by Interface Uid, Init Params && Resolver Parameters as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey, initParamsPtr, *resolverParams));

			}

		else if (hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(6) by Interface Uid, Offset && Resolver Parameters as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset, *resolverParams));

			getKeyFromOffset=(err==KErrNone);

			}

		else

			{

			INFO_PRINTF1(_L("Creating Implementnation(5) by Interface Uid && Resolver Parameters as a filter"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey, *resolverParams));

			}

		}

	else

		{

		if (hasInitParams && hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(4) by Uid, Offset && Construction Parameters"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset, initParamsPtr));

			getKeyFromOffset=(err==KErrNone);

			}

		else if (hasInitParams)

			{

			INFO_PRINTF1(_L("Creating Implementnation(3) by Uid && Construction Parameters"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey, initParamsPtr));

			}

		else if (hasOffset)

			{

			INFO_PRINTF1(_L("Creating Implementnation(2) by Uid && offset defined by interface"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, offset));

			getKeyFromOffset=(err==KErrNone);

			}

		else

			{

			INFO_PRINTF1(_L("Creating Implementnation(1) by Uid"));

			TRAP( err, iImplementationInterface =

				REComSession::CreateImplementationL(impUid, iDTorKey ));

			}

		}

	if ( getKeyFromOffset )

		{

		TUint8*	uidPtr=REINTERPRET_CAST(TUint8*, iImplementationInterface) + offset;

		TUid*	uid=REINTERPRET_CAST(TUid*, uidPtr);

		iDTorKey=*uid;

		*uid=TUid::Null();

		}

	INFO_PRINTF2(_L("Implementation created successfully. iDTorKey is %d"), iDTorKey.iUid);

	if (BlockResult()==EPass)

		{

		if( err != KErrNone )

			{

			ERR_PRINTF2(_L("Failed to create implementation with error %d"), err);

			SetError(err);

			if (iImplementationInterface != NULL)

				{

				SetBlockResult(EFail);

				ERR_PRINTF1(_L("Data verification failed: CreateImplementationL returns an error, but implementation was created"));

				}

			else

				{

				INFO_PRINTF1(_L("Data verification succcess: CreateImplementationL returns an error and implementation was not created as expected"));

				}

			}

		}

	}

void CT_EComSessionData::DoCmdDestroyedImplementation(const TDesC& aSection)

	{

	TInt	uidValue;

	if ( GetIntFromConfig(aSection, KUid(), uidValue) )

		{

		iDTorKey = TUid::Uid(uidValue);

		}

	INFO_PRINTF2(_L("Destroy Interface Implementation. UID is %d"), iDTorKey.iUid);

	REComSession::DestroyedImplementation(iDTorKey);

	INFO_PRINTF1(_L("REComSession::DestroyedImplementation(iDTorKey) completed"));

	DestroyData();

	INFO_PRINTF1(_L("Interface implementation destroyed"));

	}

/**

 Virtual RunL - Called on completion of an asynchronous command

 @internalComponent

 @see MTPActiveCallback

 @param aActive Active Object that RunL has been called on

 @pre N/A

 @post N/A

 @leave system wide error code

*/

void CT_EComSessionData::RunL(CActive* aActive, const TInt aIndex)

	{

	if ( aActive==iActiveNotifyOnChange )

		{

		RunNotifyOnChangeL( aIndex );

		}

	else

		{

		ERR_PRINTF1(_L("Stray signal"));

		SetBlockResult(EFail);

		}

	}

/**

 RunNotifyOnChangeL - Process RunL for iActiveNotifyOnChange

 @internalComponent

 @pre N/A

 @post N/A

 @leave system wide error code

*/

void CT_EComSessionData::RunNotifyOnChangeL(const TInt aIndex)

	{

	TInt	err=iActiveNotifyOnChange->iStatus.Int();

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("RunL Error %d"), err);

		SetAsyncError(aIndex, err);

		}

	else

		{

		INFO_PRINTF1(_L("RunNotifyOnChangeL OK"));

		}

   	DecOutstanding();

	}