/*

 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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 "tupsclientstep.h"  

 #include "tupsintegdefs.h"

 #include "tupsproperty.h"

 #include <e32property.h>

 TServiceRequestParameters::TServiceRequestParameters() 

 	:iServiceUID(0), iServerName(0),iDestination(0), iExpectedError(0),

 	 iOpaqueData(0), iSelectDialogOption(0), iButtonsDisplayed(0),

 	 iDialogCreatorInvoked(0), iPolicyEvaluatorInvoked(0), iAccessGranted(0),

 	 iCloseSession(EFalse), iHoldEvaluatorOpen(EFalse), iHoldPrepareDialogOpen(EFalse), iHoldDisplayDialogOpen(EFalse),

 	 iRequestDurationThreshold(0), iLeaveDialog(EFalse), iLeaveEvaluator(EFalse), iCancelUpsRequest(EFalse),

 	 iPlatSecPass(EFalse),iForcePrompt(EFalse),iExpectedEvaluatorInfo(0),iSelectFingerprint(0),

 	 iWaitUntilFileAppears(0)	 	 	 	 

 	{	

 	};   

 COpenSession* COpenSession::NewL(const TPtrC& aServerName)

 	{

 	COpenSession * self = new (ELeave) COpenSession(); 

 	CleanupStack::PushL(self);

 	self->ConstructL(aServerName);

 	CleanupStack::Pop(self);

 	return(self);

 	} // End of function

 void COpenSession::ConstructL(const TPtrC& aServerName)

 	{

 	iServerName = aServerName;

 	iPointerToServer = new RUpsTestServ;

 	User::LeaveIfError(iPointerToServer->Connect(iServerName, ETrue));

     iPointerToSession = new RUpsTestSession;

 	User::LeaveIfError(iPointerToSession->Open(*iPointerToServer));

 	} // End of function

 COpenSession::~COpenSession() 

 	{	

 	if (iPointerToSession)

 		iPointerToSession->Close();

 	if (iPointerToServer)

 		iPointerToServer->Close();

 	delete iPointerToSession;

     delete iPointerToServer;

     }  // End of function

 CUpsClientStep::~CUpsClientStep()

 /**

  * Destructor

  */

 	{

 	iArraySersToRequest.Close();   

 	CloseAllOpenSessions();

 	delete iPropertyReader;

   	__UHEAP_MARKEND;

 	} // End of function

 CUpsClientStep::CUpsClientStep()

 /**

  * Constructor

  */

 	{

 	SetTestStepName(KUPSClientStep);

 	} // End of function

 TVerdict CUpsClientStep::doTestStepPreambleL()

 /**

  * @return - TVerdict code

  * Override of base class virtual

  */

 	{

  	__UHEAP_MARK;

 	// Read values to config servers from INI file. (ARRAY of values)

     // Read how many times the test step needs to be repeated.

     TName fStepRepeat(_L("StepRepeat"));

     TInt  repeats;

     if(GetIntFromConfig(ConfigSection(),fStepRepeat,repeats))

 	    {

 	   	iStepRepeat=repeats;

 	    }

 	else

 		{

 		iStepRepeat=1;		

 		}

     // Read values for test sequence from INI file. (ARRAY of values)

 	TInt index=0;

 	TName fUseServiceUID;

 	fUseServiceUID.Format(_L("UseServiceUID_%d"),index);

 	TName fUseServerName;

 	fUseServerName.Format(_L("UseServerName_%d"),index);

 	TName fDestination;

 	fDestination.Format(_L("Destination_%d"),index);

 	TName fExpectedError;

 	fExpectedError.Format(_L("ExpectedError_%d"),index);

 	TName fUseOpaqueData;

 	fUseOpaqueData.Format(_L("UseOpaqueData_%d"),index);

 	TName fSelectDialogOption;

 	fSelectDialogOption.Format(_L("SelectDialogOption_%d"),index); 

 	TName fButtonsDisplayed;

 	fButtonsDisplayed.Format(_L("ButtonsDisplayed_%d"),index);

 	TName fDialogCreatorInvoked;

 	fDialogCreatorInvoked.Format(_L("DialogCreatorInvoked_%d"),index);

 	TName fPolicyEvaluatorInvoked;

 	fPolicyEvaluatorInvoked.Format(_L("PolicyEvaluatorInvoked_%d"),index);

 	TName fAccessGranted;

 	fAccessGranted.Format(_L("AccessGranted_%d"), index);

 	TName fCloseSession;

 	fCloseSession.Format(_L("CloseSession_%d"), index);

 	TName fHoldEvaluatorOpen;

 	fHoldEvaluatorOpen.Format(_L("HoldEvaluatorOpen_%d"), index);

 	TName fHoldPrepareDialogOpen;

 	fHoldPrepareDialogOpen.Format(_L("HoldPrepareDialogOpen_%d"), index);

 	TName fHoldDisplayDialogOpen;

 	fHoldDisplayDialogOpen.Format(_L("HoldDisplayDialogOpen_%d"), index);

 	TName fRequestDurationThreshold;

 	fRequestDurationThreshold.Format(_L("RequestDurationThreshold_%d"), index);

 	TName fLeaveDialog;

 	fLeaveDialog.Format(_L("LeaveDialog_%d"), index);

 	TName fLeaveEvaluator;

 	fLeaveEvaluator.Format(_L("LeaveEvaluator_%d"), index);

 	TName fCancelUpsRequest;

 	fCancelUpsRequest.Format(_L("CancelUpsRequest_%d"), index);

 	TName fPlatSecPass;

 	fPlatSecPass.Format(_L("PlatSecPass_%d"), index);

 	TName fForcePrompt;

 	fForcePrompt.Format(_L("ForcePrompt_%d"), index);

 	TName fExpectedEvaInfo;

 	fExpectedEvaInfo.Format(_L("ExpectedEvaluatorInfo_%d"), index);

 	TName fSelectFingerprint;

 	fSelectFingerprint.Format(_L("SelectFingerprint_%d"), index);

 	TName fWaitUntilFileAppears;

 	fWaitUntilFileAppears.Format(_L("WaitUntilFileAppears_%d"), index);

 	TInt	useServiceUID;

 	TPtrC   useServerName;

 	TPtrC   destination;

 	TInt	expectedError;

 	TPtrC   useOpaqueData;

     TPtrC	selectDialogOption;

 	TInt	buttonsDisplayed;

 	TInt    dialogCreatorInvoked;

 	TInt	policyEvaluatorInvoked;

 	TPtrC	accessGranted;

 	TBool	closeSession;

 	TBool   holdEvaluatorOpen;

 	TBool   holdPrepareDialogOpen;

 	TBool   holdDisplayDialogOpen;

 	TInt 	requestDurationThreshold;

 	TBool   leaveDialog;

 	TBool   leaveEvaluator;

 	TBool   cancelUpsRequest;

 	TBool   platSecPass;

 	TBool   forcePrompt;

 	TInt    expectedEvaInfo;

 	TInt	selectFingerprint;

 	TPtrC   waitUntilFileAppears;	

 	while (GetHexFromConfig(ConfigSection(), fUseServiceUID,useServiceUID)

 		&& GetStringFromConfig(ConfigSection(),fUseServerName,useServerName)

 		&& GetStringFromConfig(ConfigSection(),fDestination,destination)

 	  	&& GetStringFromConfig(ConfigSection(),fAccessGranted,accessGranted))

 		{

 	    TServiceRequestParameters newSerReq;

 	    newSerReq.iServiceUID = useServiceUID; 

 	    newSerReq.iServerName = useServerName;

 	    newSerReq.iDestination = destination;

 	    newSerReq.iAccessGranted = accessGranted;

         // Close session is optional.

         if(GetBoolFromConfig(ConfigSection(),fCloseSession,closeSession))

 	    	{

 	    	newSerReq.iCloseSession = closeSession;

 	    	}

 	    // use of dialog creator is optional.

 	    if(GetStringFromConfig(ConfigSection(),fSelectDialogOption,selectDialogOption)

 		&& GetIntFromConfig(ConfigSection(),fButtonsDisplayed,buttonsDisplayed)

 		&& GetIntFromConfig(ConfigSection(),fDialogCreatorInvoked,dialogCreatorInvoked))

 	    	{

 		    newSerReq.iSelectDialogOption = selectDialogOption;

 		    newSerReq.iButtonsDisplayed	= buttonsDisplayed;

 		    newSerReq.iDialogCreatorInvoked	= dialogCreatorInvoked;

 	    	} 

 	    // use of policy evaluator is optional.

 	    if(GetIntFromConfig(ConfigSection(),fPolicyEvaluatorInvoked,policyEvaluatorInvoked))

 	    	{

 	       	newSerReq.iPolicyEvaluatorInvoked = policyEvaluatorInvoked;

 	    	}

 	    // Opaque data is optional

 	    if(GetStringFromConfig(ConfigSection(),fUseOpaqueData,useOpaqueData))

 	    	{

 	       	HBufC8* converter = HBufC8::NewLC(useOpaqueData.Length());

 			converter->Des().Copy(useOpaqueData);	

 	       	newSerReq.iOpaqueData = converter->Ptr() ;	

 	       	CleanupStack::PopAndDestroy(); //converter 

 	    	}

 	    // Expected error is optional.

 	    if(GetIntFromConfig(ConfigSection(),fExpectedError,expectedError))

 	    	{

 			newSerReq.iExpectedError = expectedError;

 	    	}

 	    // hold policy evaluator open is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fHoldEvaluatorOpen, holdEvaluatorOpen))

 	    	{

 			newSerReq.iHoldEvaluatorOpen =	holdEvaluatorOpen;

 	    	}

 	    // hold prepare dialog open is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fHoldPrepareDialogOpen, holdPrepareDialogOpen))

 	    	{

 			newSerReq.iHoldPrepareDialogOpen =	holdPrepareDialogOpen;

 	    	}

 	    // hold display dialog open is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fHoldDisplayDialogOpen, holdDisplayDialogOpen))

 	    	{

 			newSerReq.iHoldDisplayDialogOpen =	holdDisplayDialogOpen;

 	    	}

 	    // request duration threshold - if a request takes 

 	    // longer than this threshold it will fail the test

 	    if(GetIntFromConfig(ConfigSection(),fRequestDurationThreshold, requestDurationThreshold))

 	    	{

 	       	newSerReq.iRequestDurationThreshold = requestDurationThreshold;

 	    	}

 	    // leave dialog is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fLeaveDialog,leaveDialog))

 	    	{

 	    	newSerReq.iLeaveDialog = leaveDialog;

 	   		}

 	    // leave Evaluator is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fLeaveEvaluator,leaveEvaluator))

 	    	{

 			newSerReq.iLeaveEvaluator = leaveEvaluator;	

 	    	}

 	    // Cancel ups request is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fCancelUpsRequest,cancelUpsRequest))

 	    	{

 	  		newSerReq.iCancelUpsRequest = cancelUpsRequest;		

 	    	}

 	    // plat sec pass is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fPlatSecPass,platSecPass))

 	    	{

 			newSerReq.iPlatSecPass = platSecPass;

 	    	}

 	    // Force prompt is optional.

 	    if(GetBoolFromConfig(ConfigSection(),fForcePrompt,forcePrompt))

 	    	{

 			newSerReq.iForcePrompt = forcePrompt;

 	    	}

 	    // use of policy evaluator is optional.

 	    if(GetIntFromConfig(ConfigSection(),fExpectedEvaInfo,expectedEvaInfo))

 	    	{

 	       	newSerReq.iExpectedEvaluatorInfo = expectedEvaInfo;

 	    	}

 	    // Fingerprint selection is optional.

 	    if(GetIntFromConfig(ConfigSection(),fSelectFingerprint,selectFingerprint))

 	    	{

 	       	newSerReq.iSelectFingerprint = selectFingerprint;

 	    	}

 	    // iRepeatUntilFileAppears is optional.

 	    if(GetStringFromConfig(ConfigSection(),fWaitUntilFileAppears,waitUntilFileAppears))

 	    	{

 	    	newSerReq.iWaitUntilFileAppears = waitUntilFileAppears;

 	    	}

 	    // Add the new service to be requested to array.

 	    iArraySersToRequest.Append(newSerReq);

 	    index++;

 	    fUseServiceUID.Format(_L("UseServiceUID_%d"),index);

 	    fUseServerName.Format(_L("UseServerName_%d"),index);

 	    fDestination.Format(_L("Destination_%d"),index);

 	    fExpectedError.Format(_L("ExpectedError_%d"),index);

 	    fUseOpaqueData.Format(_L("UseOpaqueData_%d"),index);

 	    fSelectDialogOption.Format(_L("SelectDialogOption_%d"),index);

 	    fButtonsDisplayed.Format(_L("ButtonsDisplayed_%d"),index);

 	    fDialogCreatorInvoked.Format(_L("DialogCreatorInvoked_%d"),index); 

 	    fPolicyEvaluatorInvoked.Format(_L("PolicyEvaluatorInvoked_%d"),index);

 	    fAccessGranted.Format(_L("AccessGranted_%d"), index);  

 	    fCloseSession.Format(_L("CloseSession_%d"), index);

 	    fHoldEvaluatorOpen.Format(_L("HoldEvaluatorOpen_%d"), index);

 	    fHoldPrepareDialogOpen.Format(_L("HoldPrepareDialogOpen_%d"), index);

 	    fHoldDisplayDialogOpen.Format(_L("HoldDisplayDialogOpen_%d"), index);

 		fRequestDurationThreshold.Format(_L("RequestDurationThreshold_%d"), index);

 	    fLeaveDialog.Format(_L("LeaveDialog_%d"), index);

 	    fLeaveEvaluator.Format(_L("LeaveEvaluator_%d"), index);

 	    fCancelUpsRequest.Format(_L("CancelUpsRequest_%d"), index);

 	    fPlatSecPass.Format(_L("PlatSecPass_%d"), index);

 	    fForcePrompt.Format(_L("ForcePrompt_%d"), index);

 	   	fExpectedEvaInfo.Format(_L("ExpectedEvaluatorInfo_%d"), index);

 	   	fSelectFingerprint.Format(_L("SelectFingerprint_%d"), index);

 	   	fWaitUntilFileAppears.Format(_L("WaitUntilFileAppears_%d"), index);

 	   	}	

 	// now try for some clientStep specific stuff

 	// this ini file entry specifies the property key value for the hold flag

 	// If the hold flag property is true then monitor it until it becomes false

 	// then continue

 	TInt holdKey;

     if(GetIntFromConfig(ConfigSection(),_L("HoldClientStepKey"), holdKey))

 	    {

 		iHoldClientStepKey = holdKey;

 		// as this property is present then set it to true using a direct call to p&s api because

 		// the ups p&s api only handles policy evaluators and dialog creators and not test steps

 		User::LeaveIfError(RProperty::Set(KPropertyCreatorUid, iHoldClientStepKey, 2));

 	    }

 	// Instantiates property reader and seter

 	iPropertyReader= CUpsProperty::NewL(KPropertyCreatorUid); 

 	// reads client name and SID

 	TParse clientFullName;

 	RThread client;

 	clientFullName.Set(client.FullName(),NULL, NULL);

 	iTEFServerName=clientFullName.Name();

 	iExpectedClientSid = client.SecureId() ;

 	client.Close();

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 TVerdict CUpsClientStep::doTestStepL()

 	{

 	// loop to request for different test services.

 	TVerdict testResult= EPass;

 	TInt numServicesToRequest = iArraySersToRequest.Count();

 	if(numServicesToRequest > 0) 

 		{

 		// check if the test step needs to hold until another step allows it to continue

 		if (iHoldClientStepKey)

 			{

 			HoldClientL();

 			}

 		// repeats the sequence of test services request as many times as specified in iStepRepeat

 		for(TInt repeatTimes = 0;repeatTimes<iStepRepeat;++repeatTimes)

 			{

 			INFO_PRINTF3(_L("%S: Repeat number: %d"),&iTEFServerName,repeatTimes);

 			for(TInt index=0;index < numServicesToRequest; ++index )

 				{

 				INFO_PRINTF6(_L("%S: Service request: %d. SysServer: %S Destination: %S  ServiceUID: %X "),&iTEFServerName, index, &iArraySersToRequest[index].iServerName ,&iArraySersToRequest[index].iDestination, iArraySersToRequest[index].iServiceUID);

 				RUpsTestSession * sessionToBeUsed; 

 				sessionToBeUsed = GetSessionToServerL(iArraySersToRequest[index].iServerName);			    

 				SetTestDataL(index);

 				sessionToBeUsed->UseTestService(iRequestData,iReturnData); 

 				iServerId=sessionToBeUsed->GetServerSid();

 				// Check results.

 				if(CheckResultsL(index) == EFalse)

 					{

 					ERR_PRINTF2(_L("%S: Incorrect results"),&iTEFServerName);

 					User::Leave(KErrGeneral);

 					}

 				// Checks from config value if session need to be closed.

 				if(iArraySersToRequest[index].iCloseSession)

 					{

 					INFO_PRINTF3(_L("%S :Closing session to server: %S"),&iTEFServerName, &iArraySersToRequest[index].iServerName );    

 					CloseSessionL(iArraySersToRequest[index].iServerName);

 					}   

 				}  // End of second loop

 			}// End of first loop

 		// Sets the status of the first instance of policy evaluator and dialog creator to

 		// completed so that the coordinator step can progress in concurrent mode 	

 		SetClientStatusCompleteL();

 		}

 	else

 		{

 		testResult= EFail;

 		ERR_PRINTF2(_L("%S :Problem reading ini file"),&iTEFServerName);

 		User::Leave(KErrGeneral);	

 		}  

 	return testResult;	

 	}  // End of function

 TVerdict CUpsClientStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}

 void CUpsClientStep::HoldClientL(void)

 	{

 	RProperty checkIfStillNeedtoHold;

 	User::LeaveIfError(checkIfStillNeedtoHold.Attach(KPropertyCreatorUid, iHoldClientStepKey));

 	CleanupClosePushL(checkIfStillNeedtoHold);

 	checkIfStillNeedtoHold.Set(KPropertyCreatorUid, iHoldClientStepKey, 1);

     TRequestStatus holdStatus;

  	checkIfStillNeedtoHold.Subscribe(holdStatus);

 	TInt holdState;

 	checkIfStillNeedtoHold.Get(KPropertyCreatorUid, iHoldClientStepKey, holdState);

 	if(!holdState)

  		{

  		checkIfStillNeedtoHold.Cancel();

  		}

  	else

  		{

  		User::WaitForRequest(holdStatus);

  		}

 	RDebug::Printf("[UPS ClientStep 0x%x] HoldClient() stopped holding\n", this);

 	// set the hold state back to 1 for future holds

 	checkIfStillNeedtoHold.Set(KPropertyCreatorUid, iHoldClientStepKey, 2);

 	CleanupStack::PopAndDestroy(&checkIfStillNeedtoHold);

 	}

 TBool CUpsClientStep::FindOpenSession(const TDesC& aServerName,TInt &position)

 	{

 	TBool sessionFound = EFalse;

 	TInt sessionsCount = iArraySessionsInUse.Count();

 	for(TInt index = 0;index < sessionsCount; ++index)

 		{

 		if(!aServerName.CompareF(iArraySessionsInUse[index]->iServerName))

 			{

 			position = index;

 			sessionFound = ETrue;

 			break;

 			}

 		} 

 	return sessionFound;

 	} // End of function

 RUpsTestSession* CUpsClientStep::GetSessionToServerL(const TDesC& aServerName) 

 	{

 	// Finds out if a session is already open for server requested

 	TInt foundPos;

 	RUpsTestSession* sessionToReturn;

 	if(!FindOpenSession(aServerName,foundPos))

 		{

 		// if open session for intended server not found it creates a new one

 		COpenSession* sessionToAppend=COpenSession::NewL(aServerName);

 		iArraySessionsInUse.AppendL(sessionToAppend);		

 		foundPos = iArraySessionsInUse.Count()-1; // position of new session is last one in array. 

 		}

 	sessionToReturn = iArraySessionsInUse[foundPos]->iPointerToSession;

 	return sessionToReturn;

 	} // End of function

 void CUpsClientStep::CloseSessionL(const TDesC& aServerName) 

 	{

 	// Finds out if a session is already open for server requested

 	TInt foundPos;

 	if(!FindOpenSession(aServerName,foundPos))

 		{

 		// if a session for this server was not found it leaves.

 		ERR_PRINTF2(_L("%S: The server to be closed was not found"),&iTEFServerName);

 		User::Leave(KErrGeneral); 

 		}

 	delete iArraySessionsInUse[foundPos];  // deletes instance.

 	iArraySessionsInUse.Remove(foundPos);  // removes empty slot

 	} // End of function

 void CUpsClientStep::CloseAllOpenSessions()

 	{

 	while(iArraySessionsInUse.Count()>0)

 		{   // delete and remove first session of array.

 		delete iArraySessionsInUse[0];

 	    iArraySessionsInUse.Remove(0);	

 		}

 	iArraySessionsInUse.Close();

 	} // End of function

 void CUpsClientStep::SetTestDataL(TInt aIndex)

 	{

 	// Set data for request.

 	iReturnData.iError=KErrNone;

 	iServerId=0;

 	iRequestData.iMeasureResponceTime = EFalse;

 	iRequestData.iServiceUid = TUid::Uid(iArraySersToRequest[aIndex].iServiceUID);

 	if(iArraySersToRequest[aIndex].iOpaqueData.CompareF(_L8(""))==0)

 		{

 		iRequestData.iOpaquePresent = EFalse;

 		}

 	else

 		{

 		iRequestData.iOpaquePresent = ETrue;

 		iRequestData.iOpaqueData =iArraySersToRequest[aIndex].iOpaqueData;	

 		}

 	iRequestData.iDestination = iArraySersToRequest[aIndex].iDestination;

 	iRequestData.iCancelRequest = iArraySersToRequest[aIndex].iCancelUpsRequest;

 	iRequestData.iPlatSecPass = iArraySersToRequest[aIndex].iPlatSecPass;

 	// set properties for policy evaluator.

 	if (iArraySersToRequest[aIndex].iPolicyEvaluatorInvoked != 0)

 		{

 		//Reset various publisher and suscribe properties for policy evaluator.

 		TInt instance = iArraySersToRequest[aIndex].iPolicyEvaluatorInvoked;

 	  	iPropertyReader->SetL(instance,KPe_Status,CUpsProperty::EPolicyEvaluator, KUpsPeStatusReset);

 	  	iPropertyReader->SetL(instance,KPe_ClientSid,CUpsProperty::EPolicyEvaluator, 0);

 	  	iPropertyReader->SetL(instance,KPe_ServerSid,CUpsProperty::EPolicyEvaluator, 0);

 	  	TBool leaveEvaluator = iArraySersToRequest[aIndex].iLeaveEvaluator; 

 	  	iPropertyReader->SetL(instance,KPe_Leave,CUpsProperty::EPolicyEvaluator, leaveEvaluator);

 	  	iPropertyReader->SetL(instance,KPe_Error,CUpsProperty::EPolicyEvaluator, KErrNone);

 	  	TBool holdEvaluatorOpen = iArraySersToRequest[aIndex].iHoldEvaluatorOpen;

 	  	iPropertyReader->SetL(instance,KPe_HoldEvaluatorOpen,CUpsProperty::EPolicyEvaluator, holdEvaluatorOpen);

 	  	TBool forcePrompt = iArraySersToRequest[aIndex].iForcePrompt; 

 	  	iPropertyReader->SetL(instance,KPe_ForcePrompt,CUpsProperty::EPolicyEvaluator, forcePrompt);

 	  	iPropertyReader->SetL(instance,KPe_EvaluatorInfo,CUpsProperty::EPolicyEvaluator, 0);

 		}

 	// set properties for dialog creator.

 	if (iArraySersToRequest[aIndex].iDialogCreatorInvoked != 0)

 		{

 		//Reset various publisher and suscribe properties for dialog creator.

 		TInt instance = iArraySersToRequest[aIndex].iDialogCreatorInvoked;

 	  	iPropertyReader->SetL(instance,KDc_Status,CUpsProperty::EDialogCreator, KUpsDcStatusReset);

 	  	iPropertyReader->SetL(instance,KDc_ClientSid,CUpsProperty::EDialogCreator, 0);

 	  	iPropertyReader->SetL(instance,KDc_ServerSid,CUpsProperty::EDialogCreator, 0);

 	  	TBool dialogLeave = iArraySersToRequest[aIndex].iLeaveDialog ;

 	  	iPropertyReader->SetL(instance,KDc_Leave,CUpsProperty::EDialogCreator, dialogLeave);

 	  	iPropertyReader->SetL(instance,KDc_Error,CUpsProperty::EDialogCreator, KErrNone);

 	  	iPropertyReader->SetL(instance,KDc_UpsRequestedButtons,CUpsProperty::EDialogCreator, 0);

 	    TInt buttonToPress = ButtonToInt(iArraySersToRequest[aIndex].iSelectDialogOption);

 	  	iPropertyReader->SetL(instance,KDc_WhichButtonToPress,CUpsProperty::EDialogCreator, buttonToPress);

 	  	TBool holdPrepareDialogOpen = iArraySersToRequest[aIndex].iHoldPrepareDialogOpen;

 	  	iPropertyReader->SetL(instance,KDc_HoldPrepareDialogOpen,CUpsProperty::EDialogCreator, holdPrepareDialogOpen);

 	  	TBool holdDisplayDialogOpen = iArraySersToRequest[aIndex].iHoldDisplayDialogOpen;

 	  	iPropertyReader->SetL(instance,KDc_HoldDisplayDialogOpen,CUpsProperty::EDialogCreator, holdDisplayDialogOpen);

 	  	TBool selectFingerprint = iArraySersToRequest[aIndex].iSelectFingerprint ;

 	  	iPropertyReader->SetL(instance,KDc_SelectFingerprint,CUpsProperty::EDialogCreator, selectFingerprint);

 		}

 	}  // End of function.

 void CUpsClientStep::SetClientStatusCompleteL()

 /**

  * Sets the status of the first policy evaluator invoked by the client to "KUpsClientCompleted" so that

  * the coordinator step can determine when the step has completely finish and progress in Concurrent mode

  *

  * NOTE: When using the Coordinator in this manner, ALL requests made to UPS must invoke the same instance

  * of the Policy Evaluator and Dialog Creator! e.g. Policy Evalutor 1 and Dialog Creator 1

  */	

  	{

 	TInt requestCount = iArraySersToRequest.Count();

 	for(TInt i=0; i<requestCount; ++i)

 		{

 		if (iArraySersToRequest[i].iPolicyEvaluatorInvoked != 0)

 			{	 

 			TInt instance = iArraySersToRequest[i].iPolicyEvaluatorInvoked;

 			iPropertyReader->SetL(instance,KPe_Status,CUpsProperty::EPolicyEvaluator, KUpsClientCompleted);

 			iPropertyReader->SetL(instance,KDc_Status,CUpsProperty::EDialogCreator, KUpsClientCompleted);

 			break;

 			}	

 		}

 	}

 TUpsDecision CUpsClientStep::StringToTUpsDecision(const TPtrC& aString)

 	{

 	if(aString.CompareF(_L("Yes"))==0)

 		{

 		return TUpsDecision(EUpsDecYes);

 		}

 	else if(aString.CompareF(_L("No"))==0)

 		{

 		return TUpsDecision(EUpsDecNo);

 		}

 	else if(aString.CompareF(_L("SessionYes"))==0)

 		{

 		return TUpsDecision(EUpsDecSessionYes);

 		}

 	else

 		{

 		return TUpsDecision(EUpsDecSessionNo);

 		}	

 	} // End of function.

 TPtrC	CUpsClientStep::TUpsDecisionToString(TUpsDecision aDecision)

 	{

 	if(aDecision == EUpsDecYes)

 		{

 		return _L("Yes");

 		}

 	else if(aDecision == EUpsDecNo)

 		{

 		return _L("No");

 		}

 	else if(aDecision == EUpsDecSessionYes)

 		{

 		return _L("SessionYes");

 		}

 	else if(aDecision == EUpsDecSessionNo)

 		{

 		return _L("SessionNo");

 		}

 	else 

 		{

 		return _L("Undefined");

 		}

 	} // End of function.

 TInt CUpsClientStep::ButtonToInt(const TPtrC& aButton)

 	{

 	if(aButton.CompareF(_L("Yes"))==0)

 		{

 		return KYes;

 		}

 	else if(aButton.CompareF(_L("No"))==0)

 		{

 		return KNo;

 		}

 	else if(aButton.CompareF(_L("Always"))==0)

 		{

 		return KAlways;

 		}

 	else if(aButton.CompareF(_L("SessionYes"))==0)

 		{

 		return KSessionYes;

 		}

 	else if(aButton.CompareF(_L("SessionNo"))==0)

 		{

 		return KSessionNo;

 		}

 	else if(aButton.CompareF(_L("Never"))==0)

 		{

 		return KNever;

 		}

 	else return KNone;

 	}  // End of function.

 TBool CUpsClientStep::CheckResultsL(TInt aIndex)

 	{

 	TBool theReturn = ETrue; 

 	if(iArraySersToRequest[aIndex].iExpectedError == KErrNone)   

 		{

 		TUpsDecision expectedDecision = StringToTUpsDecision(iArraySersToRequest[aIndex].iAccessGranted);

 		if(expectedDecision != iReturnData.iDecision)

 	 		{

 	 		TPtrC decisionReceived(TUpsDecisionToString(iReturnData.iDecision));

 	 		ERR_PRINTF4(_L("%S: Decision expected: %S ,Decision received: %S"),&iTEFServerName, &iArraySersToRequest[aIndex].iAccessGranted, &decisionReceived);  

 	 		theReturn=EFalse;	

 	 		}		

 		}

  	if(iArraySersToRequest[aIndex].iExpectedError != iReturnData.iError) 

  		{

  		// Incorrect error code returned.

  		theReturn=EFalse;

  		ERR_PRINTF3(_L("%S: Error code expected: %d"),&iTEFServerName,iArraySersToRequest[aIndex].iExpectedError);

  		ERR_PRINTF3(_L("%S: Error code Received: %d"),&iTEFServerName,iReturnData.iError);

  		}

  	// checks returned properties from dialog creator & policy evaluator.

  	if ( CheckDialogCreatorResultsL(aIndex) == EFalse || CheckPolicyEvaluatorResultsL(aIndex) == EFalse)

  		{

  			theReturn = EFalse;

  		}

  	// display the request duration and check against the ini file value, if supplied

 	INFO_PRINTF3(_L("%S: UPS decision request duration: %u milliseconds"),&iTEFServerName, iReturnData.iRequestDuration);

 	if (iArraySersToRequest[aIndex].iRequestDurationThreshold > 0)

 		{

 		// check whether the request duration was too long

 		if (static_cast<TInt>(iReturnData.iRequestDuration) > iArraySersToRequest[aIndex].iRequestDurationThreshold)

 			{

 	 		ERR_PRINTF3(_L("%S: UPS decision request took too long: %u"), &iTEFServerName, iArraySersToRequest[aIndex].iRequestDurationThreshold);

 	 		theReturn = EFalse;

 			}

 		}

 	return theReturn;

 	}  // End of function.

 TBool CUpsClientStep::CheckDialogCreatorResultsL(TInt aIndex)

 	{

 	TBool checkPassed = ETrue;

 	// checks return properties from dialog creator.

  	if (iArraySersToRequest[aIndex].iDialogCreatorInvoked != 0)

 		{

 		TInt instanceDia = iArraySersToRequest[aIndex].iDialogCreatorInvoked;

 		TInt dialogError = 0;

 		iPropertyReader->GetL(instanceDia,KDc_Error,CUpsProperty::EDialogCreator, dialogError);

 		// Checks that any error encountered by dialog creator is transmited by UPS to system server

 		if(dialogError != iReturnData.iError && dialogError!=KErrNone)

 			{

 			ERR_PRINTF3(_L("%S: Dialog creator found an error: %d"),&iTEFServerName,dialogError);

 			checkPassed = EFalse; 	

 			}

 		TInt clientSidDia=0;

 		iPropertyReader->GetL(instanceDia,KDc_ClientSid,CUpsProperty::EDialogCreator, clientSidDia);

 	    if(iExpectedClientSid != clientSidDia)

 		    {

 		    ERR_PRINTF2(_L("%S: Client SID returned by dialog creator is not what is expected"),&iTEFServerName);

 			checkPassed = EFalse;

 		    }

 	    TInt buttonsDisplayed=0;

 		iPropertyReader->GetL(instanceDia,KDc_UpsRequestedButtons,CUpsProperty::EDialogCreator, buttonsDisplayed);

 	    TInt32 expectedButtonsDisplayed=iArraySersToRequest[aIndex].iButtonsDisplayed;

 	    if(expectedButtonsDisplayed != buttonsDisplayed)

 		    {

 		   	ERR_PRINTF2(_L("%S: Incorrect buttons displayed."),&iTEFServerName);

 		   	ERR_PRINTF3(_L("%S: Buttons displayed expected: %d"),&iTEFServerName,expectedButtonsDisplayed);

 		   	ERR_PRINTF3(_L("%S: Buttons displayed received: %d"),&iTEFServerName,buttonsDisplayed);

 			checkPassed = EFalse;

 		    }

 	    TInt serverSidDia=0;

 		iPropertyReader->GetL(instanceDia,KDc_ServerSid,CUpsProperty::EDialogCreator, serverSidDia);

 	    if(iServerId != serverSidDia)

 		    {

 		   	ERR_PRINTF2(_L("%S: Server SID returned by dialog creator is not what is expected"),&iTEFServerName);

 			checkPassed = EFalse;

 		    } 

 	    TInt serviceSidDia=0;

 		iPropertyReader->GetL(instanceDia,KDc_ServiceId,CUpsProperty::EDialogCreator, serviceSidDia);

 		if(serviceSidDia != iArraySersToRequest[aIndex].iServiceUID)

 		    {

 		   	ERR_PRINTF3(_L("%S: Service ID reported by dialog creator is not what is expected: %d"),&iTEFServerName,serviceSidDia);

 			checkPassed = EFalse;

 		    }  

 		}

 	return checkPassed;

 	}  // End of function.

 TBool CUpsClientStep::CheckPolicyEvaluatorResultsL(TInt aIndex)

 	{

 	TBool checkPassed = ETrue;

 	if (iArraySersToRequest[aIndex].iPolicyEvaluatorInvoked != 0)

 		{

 		TInt instanceEva = iArraySersToRequest[aIndex].iPolicyEvaluatorInvoked;

 		TInt evaluatorError = 0;

 		// Checks that any error encountered by policy evaluator is transmited by UPS to system server

 		iPropertyReader->GetL(instanceEva,KPe_Error,CUpsProperty::EPolicyEvaluator, evaluatorError);

 		if(evaluatorError != iReturnData.iError && evaluatorError!=KErrNone)

 			{

 			ERR_PRINTF3(_L("%S: Policy evaluator found an error: %d"),&iTEFServerName,evaluatorError);

 			checkPassed = EFalse; 	

 			}

 		TInt clientSidEva=0;

 		iPropertyReader->GetL(instanceEva,KPe_ClientSid,CUpsProperty::EPolicyEvaluator, clientSidEva);

 	    if(iExpectedClientSid != clientSidEva)

 		    {

 		   	ERR_PRINTF2(_L("%S: Client SID returned by policy evaluator is not what is expected"),&iTEFServerName);

 			checkPassed = EFalse;

 		    }

 	    TInt serverSidEva=0;

 		iPropertyReader->GetL(instanceEva,KPe_ServerSid,CUpsProperty::EPolicyEvaluator, serverSidEva);

 	    if(iServerId != serverSidEva)

 		    {

 		   	ERR_PRINTF2(_L("%S: Server SID returned by policy evaluator is not what is expected"),&iTEFServerName);

 			checkPassed = EFalse;

 		    } 

 	    TInt serviceSidEva = 0;

 		iPropertyReader->GetL(instanceEva,KPe_ServiceId,CUpsProperty::EPolicyEvaluator, serviceSidEva);

 		if(serviceSidEva != iArraySersToRequest[aIndex].iServiceUID)

 		    {

 		   	ERR_PRINTF3(_L("%S: Service ID reported by policy evaluator is not what is expected: %d"),&iTEFServerName,serviceSidEva);

 			checkPassed = EFalse;

 		    }

 	    if( iArraySersToRequest[aIndex].iForcePrompt)

 		    {

 	    	// Read evaluator info

 	    	TInt evaluatorInfo = 0;

 			iPropertyReader->GetL(instanceEva,KPe_EvaluatorInfo,CUpsProperty::EPolicyEvaluator, evaluatorInfo);

 	    	if(evaluatorInfo != iArraySersToRequest[aIndex].iExpectedEvaluatorInfo)

 	    		{

 	    		ERR_PRINTF4(_L("%S: incorrect evaluator info:Expected: %d Received: %d"),&iTEFServerName,iArraySersToRequest[aIndex].iExpectedEvaluatorInfo,evaluatorInfo);

 	    		checkPassed = EFalse;

 	    		}

 		    }

 		}

 	return checkPassed;

 	}  // End of function.