// Copyright (c) 2006-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 "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// @file ctlbsclientstep_UpdateOptions.cpp

// This is the class implementation for the UpdateOptions Tests

// 

//

#include "ctlbsclientstepupdateoptions.h"

#include <lbs.h>

#include <lbssatellite.h>

#include "tlbsutils.h"

#include "ctlbsasyncwaiter.h"

#define EXPECTED_GPS_ACCURACY_HORIZONTAL 100

#define EXPECTED_GPS_ACCURACY_VERTICAL 100

const TTimeIntervalMicroSeconds KTimestampMargin = 500000; //+/-0.5s

/**

 */

TBool CT_LbsClientStep_UpdateOptions::VerifyFirstPosTime(const TTime& aTimeRequested, const TPositionInfo& aPosInfo, const TPositionUpdateOptions& aUpdateOpts)

	{

	TTime timeReceived, timeStamp;

	TPosition pos;

    TInt64 maxtime;

    maxtime = aUpdateOpts.UpdateTimeOut().Int64();

	if(!maxtime)	

		{

		#pragma message("TO DO: CT_LbsClientStep_UpdateOptions::VerifyFirstPosTime - Update when moduleinfo supported")	

		const TTimeIntervalMicroSeconds ttff = 90*1000000;	// TO DO - this should be retrieved from the module info (currently hardcoded in locserver too)

		maxtime = ttff.Int64();

		}

	// get current time

	timeReceived.UniversalTime();

	// get the position data:

	aPosInfo.GetPosition(pos);

	INFO_PRINTF1(_L("First position received at: "));	

	INFO_PRINTF4(_L("%d/%d/%d"), timeReceived.DateTime().Day() + 1, timeReceived.DateTime().Month() + 1, timeReceived.DateTime().Year());

	INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeReceived.DateTime().Hour(), timeReceived.DateTime().Minute(), timeReceived.DateTime().Second(), timeReceived.DateTime().MicroSecond());

	timeStamp = pos.Time();

	INFO_PRINTF1(_L("First position timeStamp: "));

	INFO_PRINTF4(_L("%d/%d/%d"), timeStamp.DateTime().Day() + 1, timeStamp.DateTime().Month() + 1, timeStamp.DateTime().Year());

	INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeStamp.DateTime().Hour(), timeStamp.DateTime().Minute(), timeStamp.DateTime().Second(), timeStamp.DateTime().MicroSecond());	

	TInt64 timediff;

	timediff = timeReceived.Int64() - aTimeRequested.Int64();

	// *first* position received can arrive 'immediately' and up to timeout, or maxtimetofirstfix if timeout not specified

	if(timediff > maxtime)

		{

		INFO_PRINTF1(_L("Failed: First Position received outside time range"));

		return FALSE;									

		}

	else

		{

		return TRUE;

		}

	}

/**

 aPosCount - which position in a set of periodic positions this is (first position = 0)

 */

TBool CT_LbsClientStep_UpdateOptions::VerifyPosTime(const TTime& aTimeFirstPosStamped, const TPositionUpdateOptions& aUpdateOpts, TPositionInfo& aPosInfo, TInt aPosCount)

	{

	TTime timeReceived, timeStamp;

	TPosition pos;

    TInt64 interval = aUpdateOpts.UpdateInterval().Int64();	

    TTimeIntervalMicroSeconds timeout;

    timeout = aUpdateOpts.UpdateTimeOut().Int64();

    // should call different function for first position:		

    __ASSERT_ALWAYS(aPosCount > 0, User::Panic(_L("Update options test"), KErrArgument));				

	// get current time

	timeReceived.UniversalTime();

	// get the position data:

	aPosInfo.GetPosition(pos);

	INFO_PRINTF1(_L("Position received at: "));	

	INFO_PRINTF4(_L("%d/%d/%d"), timeReceived.DateTime().Day() + 1, timeReceived.DateTime().Month() + 1, timeReceived.DateTime().Year());

	INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeReceived.DateTime().Hour(), timeReceived.DateTime().Minute(), timeReceived.DateTime().Second(), timeReceived.DateTime().MicroSecond());

	timeStamp = pos.Time();

	INFO_PRINTF1(_L("Position timeStamp: "));

	INFO_PRINTF4(_L("%d/%d/%d"), timeStamp.DateTime().Day() + 1, timeStamp.DateTime().Month() + 1, timeStamp.DateTime().Year());

	INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeStamp.DateTime().Hour(), timeStamp.DateTime().Minute(), timeStamp.DateTime().Second(), timeStamp.DateTime().MicroSecond());

	TTime windowstart = aTimeFirstPosStamped + static_cast<TTimeIntervalMicroSeconds>(aPosCount * interval) - KTimestampMargin;

	TTime windowend = windowstart + timeout + KTimestampMargin;

	INFO_PRINTF1(_L("valid window start: "));	

	INFO_PRINTF4(_L("%d/%d/%d"), windowstart.DateTime().Day() + 1, windowstart.DateTime().Month() + 1, windowstart.DateTime().Year());

	INFO_PRINTF5(_L("at %d :%d :%d :%d"), windowstart.DateTime().Hour(), windowstart.DateTime().Minute(), windowstart.DateTime().Second(), windowstart.DateTime().MicroSecond());

	if(timeStamp < windowstart)

		{

		INFO_PRINTF1(_L("Failed: Position received outside time range"));

		return FALSE;

		}

	if(timeout.Int64() && (timeStamp > windowend))

		{

		INFO_PRINTF1(_L("valid window end: "));	

		INFO_PRINTF4(_L("%d/%d/%d"), windowend.DateTime().Day() + 1, windowend.DateTime().Month() + 1, windowend.DateTime().Year());

		INFO_PRINTF5(_L("at %d :%d :%d :%d"), windowend.DateTime().Hour(), windowend.DateTime().Minute(), windowend.DateTime().Second(), windowend.DateTime().MicroSecond());

		return FALSE;

		}

	else

		{

		return TRUE;

		}

	}

// constant definitions

_LIT(KLbsClientStepUpdateOptions, "LbsClientStepUpdateOptions");

/**

 *	Sets a Requestor for now - TO DO will be removed with new location server?

 */

void CT_LbsClientStep_UpdateOptions::TempSetRequestorL()

 	{	

	User::LeaveIfError(iPositioner.SetRequestor(	CRequestor::ERequestorService,

												CRequestor::EFormatApplication,

												_L("Tom Tom")));

 	}

/**

 * Destructor

 */

CT_LbsClientStep_UpdateOptions::~CT_LbsClientStep_UpdateOptions()

	{

	delete 	iLbsAdmin;	

	}

/**

 * Constructor

 */

CT_LbsClientStep_UpdateOptions::CT_LbsClientStep_UpdateOptions(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent), iLbsAdmin(NULL), iRequestedAssData(FALSE), iReceivedAssData(FALSE)

	{

	SetTestStepName(KLbsClientStep_UpdateOptions);

	}

/**

Static Constructor

*/

CT_LbsClientStep_UpdateOptions* CT_LbsClientStep_UpdateOptions::New(CT_LbsClientServer& aParent)

	{

	return new CT_LbsClientStep_UpdateOptions(aParent);

	// Note the lack of ELeave.

	// This means that having insufficient memory will return NULL;

	}	

/**

Compare UpdateOptions

*/

TBool CT_LbsClientStep_UpdateOptions::CompareUpdateOptions(TPositionUpdateOptions aPosA, TPositionUpdateOptions aPosB)

	{

	TBool isEqual = ETrue;

	if(aPosA.AcceptPartialUpdates() != aPosB.AcceptPartialUpdates()) 

		{

			return EFalse;

		}

	if(aPosA.MaxUpdateAge() != aPosB.MaxUpdateAge())

		{

			return EFalse;

		}

	if(aPosA.PositionClassSize() != aPosB.PositionClassSize())

		{

			return EFalse;

		}

	if(aPosA.PositionClassType() != aPosB.PositionClassType())

		{

			return EFalse;

		}

	if(aPosA.UpdateInterval() != aPosB.UpdateInterval())

		{

			return EFalse;

		}

	if(aPosA.UpdateTimeOut() != aPosB.UpdateTimeOut())

		{

			return EFalse;

		}

	return isEqual;

	}

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

TVerdict CT_LbsClientStep_UpdateOptions::doTestStepL()

	{

	// Generic test step used to test the LBS SetUpdateOptions API.

	INFO_PRINTF1(_L(">>CT_LbsClientStep_UpdateOptions::doTestStepL()"));

	if (TestStepResult()==EPass) 

		{

		TInt err = KErrNone;

		// Connect to self locate server.

		User::LeaveIfError(iServer.Connect());

		CleanupClosePushL(iServer);

		// Carryout unique test actions.

		TInt testCaseId;

		if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))

			{

				switch (testCaseId)

				{

				// Test case LBS-UpdateOptions-001

				case 1:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					TPositionUpdateOptions optsA;

					TPositionUpdateOptions optsB;

					iPositioner.SetUpdateOptions(optsA);

					iPositioner.GetUpdateOptions(optsB);

					if (!CompareUpdateOptions(optsA, optsB))

						{

						SetTestStepResult(EFail);

						}

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}

				// Test case LBS-UpdateOptions-002

				case 2:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					//(aInterval, aTimeOut, aMaxAge, TBool aAcceptPartialUpdates=EFalse)

					TPositionUpdateOptions optsA(-1, 0, 0, EFalse);

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}

				// Test case LBS-UpdateOptions-003

				case 3:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					TPositionUpdateOptions optsA(0, -1, 0, EFalse);

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}	

				// Test case LBS-UpdateOptions-004

				case 4:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					TPositionUpdateOptions optsA(0, 0, -1, EFalse);

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}	

				// Test case LBS-UpdateOptions-005

				case 5:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts;

					iPositioner.SetUpdateOptions(updateOpts);

					// Create a posinfo and store in our shared array for later verification.

					RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

					TPositionInfo* posInfo = new(ELeave) TPositionInfo();

					T_LbsUtils utils;

					utils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.

					posInfoArr.Append(posInfo);

					TTime timeRequested;

					timeRequested.UniversalTime();

					INFO_PRINTF1(_L("Position requested at: "));	

					INFO_PRINTF4(_L("%d/%d/%d"), timeRequested.DateTime().Day() + 1, timeRequested.DateTime().Month() + 1, timeRequested.DateTime().Year());

					INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeRequested.DateTime().Hour(), timeRequested.DateTime().Minute(), timeRequested.DateTime().Second(), timeRequested.DateTime().MicroSecond());

					// Get the actual position

					err = DoNotifyUpdateL(*posInfo);

					if (KErrNone != err || !VerifyFirstPosTime(timeRequested, *posInfo, updateOpts))

						{

						SetTestStepResult(EFail);

						}

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}

				// Test case LBS-UpdateOptions-006

				case 6:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

					T_LbsUtils utils;

					utils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.

					// Create a posinfo and store in our shared array for later verification.

					TPositionInfo* posInfo = new(ELeave) TPositionInfo();

					posInfoArr.Append(posInfo);					

					TRequestStatus status;

					TPositionUpdateOptions tempOpts;

					// set a fairly long interval (1 minute) to ensure the 2nd request doesn't complete too quicky:

					tempOpts.SetUpdateInterval(60*1000000);

					tempOpts.SetUpdateTimeOut(300*1000000);

					iPositioner.SetUpdateOptions(tempOpts);

					iPositioner.GetUpdateOptions(tempOpts);			

					TempSetRequestorL();

					TTime timeRequested;					

					TTime timeFirstStamped;							

					INFO_PRINTF2(_L("Requesting position (current interval set to %d): "),tempOpts.UpdateInterval().Int64() );

					timeRequested.UniversalTime();

					err = DoNotifyUpdateL(*posInfo);

					if (KErrNone != err)

						{

						INFO_PRINTF2(_L("Failed: Position Update failed with %d"), err);

						SetTestStepResult(EFail);

						}

					else

						{

						TPosition pos;

						posInfo->GetPosition(pos);

						// need to remember the time we received this one:		

						timeFirstStamped = pos.Time();		

						if(!VerifyFirstPosTime(timeRequested, *posInfo, tempOpts))

							{

							SetTestStepResult(EFail);									

							}

						}

					// Create another posinfo and store in our shared array for later verification.						

					posInfo = new(ELeave) TPositionInfo();

					posInfoArr.Append(posInfo);					

					INFO_PRINTF2(_L("Requesting position (current interval set to %d): "), tempOpts.UpdateInterval().Int64());

					// this should complete after original interval (1 min), despite setting a new interval while it's outstanding:

					iPositioner.NotifyPositionUpdate(*posInfo, status);	

					// set configured update options while update still outstanding:

					TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts;					

					iPositioner.SetUpdateOptions(updateOpts);

					iPositioner.GetUpdateOptions(updateOpts);

					INFO_PRINTF2(_L("Interval now set to %d microseconds"), updateOpts.UpdateInterval().Int64());

					User::WaitForRequest(status);

					// verify time for 'outstanding when interval changed' position										

					if(!VerifyPosTime(timeFirstStamped, tempOpts, *posInfo, 1))

						{

						INFO_PRINTF1(_L("CT_LbsClientStep_UpdateOptions::doTestStepL() Failed: Time received outside valid range"));

						SetTestStepResult(EFail);									

						}

					else

						{

						TInt numOfPosInfos = iParent.iSharedData->iVerifyPosInfoArr.Count() - 2;	// -2 because first 2 positions used above

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

							{

							// get current time

							timeRequested.UniversalTime();

							INFO_PRINTF1(_L("Position requested at: "));	

							INFO_PRINTF4(_L("%d/%d/%d"), timeRequested.DateTime().Day() + 1, timeRequested.DateTime().Month() + 1, timeRequested.DateTime().Year());

							INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeRequested.DateTime().Hour(), timeRequested.DateTime().Minute(), timeRequested.DateTime().Second(), timeRequested.DateTime().MicroSecond());

							//Do request to position update

							posInfo = new(ELeave) TPositionInfo();

							posInfoArr.Append(posInfo);					

							err = DoNotifyUpdateL(*posInfo);

							if (KErrNone != err)

								{

								INFO_PRINTF2(_L("Failed: Position Update failed with %d"), err);

								SetTestStepResult(EFail);

								}

							else

								{	

								if(i > 0)

									{							

									if(!VerifyPosTime(timeFirstStamped, updateOpts, *posInfo, i))

										{

										INFO_PRINTF1(_L("Failed: Position received outside time range"));

										SetTestStepResult(EFail);

										}

									}

								else	// first position

									{

									TPosition pos;

									posInfo->GetPosition(pos);

									// need to remember the time we received this one:		

									timeFirstStamped = pos.Time();		

									if(!VerifyFirstPosTime(timeRequested, *posInfo, updateOpts))

										{

										SetTestStepResult(EFail);									

										}

									}		

								}	

							}

						}

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}

				// Test case LBS-UpdateOptions-007

				case 7:

				case 107:

					{

					// Open positioner.

					User::LeaveIfError(iPositioner.Open(iServer));

					CleanupClosePushL(iPositioner);

					// For this test an additional reference position will be returned.

					if (testCaseId == 107)

						{

						// Setup netsim.

						User::LeaveIfError(OpenNetSim());

						// Request notify for the expected reference position.

						TPositionInfo actualRefPosInfo;

						err = DoNotifyUpdateL(actualRefPosInfo);

						if (err)

							{

							INFO_PRINTF2(_L("Failed test, reference position request returned err %d."), err);

							SetTestStepResult(EFail);							

							}

						// Verify reference position.

						T_LbsUtils utils;

						TPositionInfo verifyRefPosInfo;

						verifyRefPosInfo.SetPosition(iRefPos);

						if (!utils.Compare_PosInfo(verifyRefPosInfo, actualRefPosInfo))

							{

							INFO_PRINTF1(_L("Failed test, reference position incorrect."));

							SetTestStepResult(EFail);

							}

						}

					TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts;

					iPositioner.SetUpdateOptions(updateOpts);

					// verify that the set worked:

					ASSERT(updateOpts.UpdateInterval() == iParent.iSharedData->iVerifyUpdateOpts.UpdateInterval());

					// Create a posinfo and store in our shared array for later verification.

					RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

					T_LbsUtils utils;

					utils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.