/*

* Copyright (c) 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 "ctlbssimulationpsypostp600.h"

#include "simulationpsyinternalcrkeys.h"

const TInt KTrackingError = 2000000;						// 2 seconds

const TTimeIntervalMicroSeconds KClient1Interval(5000000);	// 5 seconds

const TTimeIntervalMicroSeconds KClient2Interval(10000000);	// 10 seconds

// Number of tests in this file. Increment when a new test is added.

const TInt KNrOfTests = 4;

_LIT(KName0, "TP600-0 - SPS Tracking (Independent Data Set)");

_LIT(KName1, "TP600-1 - NMEA Tracking (Common Data Set)");

_LIT(KName2, "TP600-2 - SPS Tracking (Independent Data Set)");

_LIT(KName3, "TP600-3 - NMEA Tracking (Common Data Set)");

// Data files

#ifdef __WINS__

_LIT(KSimulationSource, "z:\\system\\test\\testdata\\simulationMoveNoError.sps");

_LIT(KMagellanTracker, "z:\\system\\test\\testdata\\MagellanTracker.nme");

#else

_LIT(KSimulationSource, "c:\\system\\test\\testdata\\simulationMoveNoError.sps");

_LIT(KMagellanTracker, "c:\\system\\test\\testdata\\MagellanTracker.nme");

#endif

_LIT(KService, "service");

CT_LbsSimulationPsyPosTp600::CT_LbsSimulationPsyPosTp600(CT_LbsServer& aParent, TInt aIndex) :

	CT_LbsPortedStepBase(aParent)

	{

	iIndex = aIndex;

	}

void CT_LbsSimulationPsyPosTp600::StartL()

	{

	// Setup test environment

	SetTestStepName(GetIndexNameL(iIndex));

	iNrOfRequests = 0;

	ConnectL();

	SetupPsyL(iUidSimulationPsy);

	RunTestsL(iIndex);

	}

/*

 * From CT_LbsPortedStepBase

 * Cleans up after a test.

 * Always called, even if the test leaves.

 */

void CT_LbsSimulationPsyPosTp600::CloseTest()

	{

	ClosePositioner();

	Disconnect();

	}

TVerdict CT_LbsSimulationPsyPosTp600::doTestStepPostambleL()

	{

	SetCommonDataSetL(iOldTrpMode);

	return CT_LbsPortedStepBase::doTestStepPostambleL();

	}

/*

 * Gets the name of an individual test index

 * @param aIndex Indicates which test index name that is asked for.

 */

TPtrC CT_LbsSimulationPsyPosTp600::GetIndexNameL(TInt aIndex) const

	{

	ASSERT(aIndex < KNrOfTests);

	const TDesC* names[KNrOfTests] =

		{

		&KName0, &KName1, &KName2, &KName3

		};

	return *names[aIndex];

	}

/*

 * Contains calls to tests itself. 

 * @param aIndex test number

 */

void CT_LbsSimulationPsyPosTp600::RunTestsL(TInt aIndex)

	{

	GetCommonDataSetL(iOldTrpMode);

	switch (aIndex)

		{

		case 0:

			RunTestL(KSimulationSource, EFalse, &CT_LbsSimulationPsyPosTp600::CheckSPSTrackingWithIndependentDataSetL);

			break;

		case 1:

			RunTestL(KMagellanTracker, EFalse, &CT_LbsSimulationPsyPosTp600::CheckNMEATrackingWithIndependentDataSetL);

			break;

		case 2:

			RunTestL(KSimulationSource, ETrue, &CT_LbsSimulationPsyPosTp600::CheckSPSTrackingWithCommonDataSetL);

			break;

		case 3:

			RunTestL(KMagellanTracker, ETrue, &CT_LbsSimulationPsyPosTp600::CheckNMEATrackingWithCommonDataSetL);

			break;

		default:

			User::Leave(KErrArgument);

		}

	}

void CT_LbsSimulationPsyPosTp600::CheckSPSTrackingWithIndependentDataSetL(

		const TPositionRequest& aRequest1, 

		const TPositionRequest& aRequest2, 

		const TTime& aTimeCompleted,

		TInt aIndex)

	{

	TReal trackErr = 0.5; // possible tracking error 

	_LIT(KDistanceError, "Client 2 is further from the starting position than client 1.");

	CheckRequestTimeL(aRequest1.iStatus, aTimeCompleted.Int64() - aRequest1.iRequestTime.Int64(), aIndex == 0, KClient1Interval.Int64());

	CheckRequestTimeL(aRequest2.iStatus, aTimeCompleted.Int64() - aRequest2.iRequestTime.Int64(), aIndex == 1, KClient2Interval.Int64());

	// If client 1 returned a position, it should be further than client 2's last position

	if (aRequest1.iStatus != KRequestPending)

		{

		TReal32 distance1;

		TReal32 distance2;

		GetDistanceL(aRequest1, distance1);

		GetDistanceL(aRequest2, distance2);

		if (distance1+trackErr < distance2)

			{

			INFO_PRINTF3(_L("FAILED distance1 = %f; distance2 = %f;"), distance1, distance2);

			LogErrorAndLeaveL(KDistanceError);

			}

		}

	}

void CT_LbsSimulationPsyPosTp600::CheckNMEATrackingWithIndependentDataSetL(

		const TPositionRequest& aRequest1, 

		const TPositionRequest& aRequest2, 

		const TTime& aTimeCompleted,

		TInt aIndex)

	{

	CheckRequestTimeL(aRequest1.iStatus, aTimeCompleted.Int64() - aRequest1.iRequestTime.Int64(), aIndex == 0, KClient1Interval.Int64());

	CheckRequestTimeL(aRequest2.iStatus, aTimeCompleted.Int64() - aRequest2.iRequestTime.Int64(), aIndex == 1, KClient2Interval.Int64());

	const TCoordinate KFixes[] = 

		{ 

		TCoordinate(61.4470216666667, 23.8645783333333),		

		TCoordinate(61.4470350000000, 23.8645616666667),

		TCoordinate(61.4470383333333, 23.8645566666667),

		TCoordinate(61.4470666666667, 23.8645750000000),

		TCoordinate(61.4470855555556, 23.8645866666667),

		TCoordinate(61.4470916666667, 23.8645650000000),

		TCoordinate(61.4470950000000, 23.8645683333333)

		};

	// Client 1 should receive every fix from the file

	if (aRequest1.iStatus != KRequestPending)

		{

		static TInt numFixes;

		CheckNthFixL(aRequest1.iPositionInfo, KFixes, numFixes++);

		}

	// Client 2 should receive every fix from the file

	if (aRequest2.iStatus != KRequestPending)

		{

		static TInt numFixes;

		CheckNthFixL(aRequest2.iPositionInfo, KFixes, numFixes++);			

		}

	}

void CT_LbsSimulationPsyPosTp600::CheckSPSTrackingWithCommonDataSetL(

		const TPositionRequest& aRequest1, 

		const TPositionRequest& aRequest2, 

		const TTime& aTimeCompleted,

		TInt aIndex)

	{

	_LIT(KDistanceError1, "Client 1 should be further from the start than Client 2.");

	_LIT(KDistanceError2, "Client 2 should be further from the start than Client 1.");

	CheckRequestTimeL(aRequest1.iStatus, aTimeCompleted.Int64() - aRequest1.iRequestTime.Int64(), aIndex == 0, KClient1Interval.Int64());

	CheckRequestTimeL(aRequest2.iStatus, aTimeCompleted.Int64() - aRequest2.iRequestTime.Int64(), aIndex == 1, KClient2Interval.Int64());

	TReal32 distance1;

	TReal32 distance2;

	GetDistanceL(aRequest1, distance1);

	GetDistanceL(aRequest2, distance2);

	// If client 1 returned a position, it should be further than client 2's last position

	if (aRequest1.iStatus != KRequestPending

			&& distance1 < distance2)

		{

		LogErrorAndLeaveL(KDistanceError1);

		}

	// If client 2 returned a position, it should be further than client 1's last position

	if (aRequest2.iStatus != KRequestPending

			&& distance2 < distance1)

		{

		LogErrorAndLeaveL(KDistanceError2);

		}

	}

void CT_LbsSimulationPsyPosTp600::CheckNMEATrackingWithCommonDataSetL(

		const TPositionRequest& aRequest1, 

		const TPositionRequest& aRequest2, 

		const TTime& aTimeCompleted,

		TInt aIndex)

	{

	_LIT(KErrIncorrectFix, "Retrieved fixes are not the same.");

	CheckRequestTimeL(aRequest1.iStatus, aTimeCompleted.Int64() - aRequest1.iRequestTime.Int64(), aIndex == 0, KClient1Interval.Int64());

	CheckRequestTimeL(aRequest2.iStatus, aTimeCompleted.Int64() - aRequest2.iRequestTime.Int64(), aIndex == 1, KClient2Interval.Int64());

	if (aIndex > 0)

		{

		TPosition pos;

		TPosition pos2;

		TReal32 distance;

		if ( aRequest1.iStatus != KRequestPending && aRequest2.iStatus != KRequestPending )

			{

			aRequest1.iPositionInfo.GetPosition(pos);

			aRequest2.iPositionInfo.GetPosition(pos2);

			pos.Distance(pos2, distance);

			if (distance != 0)

				{

				LogErrorAndLeaveL(KErrIncorrectFix);

				}

			}

		}

	}

void CT_LbsSimulationPsyPosTp600::RunTestL(const TDesC& aDataFile, TBool aTrp, TCompareFunction aCheckL)

	{

	SetSimDataFileL(aDataFile);

	SetCommonDataSetL(aTrp);

	RPositioner secondPositioner;

	OpenPositionersLC(secondPositioner);

	// Set client 1 to track every 5 seconds

	TPositionUpdateOptions options(KClient1Interval);

	iPositioner.SetUpdateOptions(options);

	// Set client 2 to track every 10 seconds

	TPositionUpdateOptions options2(KClient2Interval);

	secondPositioner.SetUpdateOptions(options2);

	TTime initialTime;

	initialTime.UniversalTime();

		{

		TPositionRequest request1(iPositioner);

		TPositionRequest request2(secondPositioner);

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

			{

			request1.MakeRequestL();

			request2.MakeRequestL();

			User::WaitForRequest(request1.iStatus, request2.iStatus);

			TTime timeAfterRequest;

			timeAfterRequest.UniversalTime();

			// Check that requested positions meet test criteria

			(*this.*aCheckL)(request1, request2, timeAfterRequest, i);

			}

		}

	CleanupStack::PopAndDestroy(&secondPositioner);

	}

void CT_LbsSimulationPsyPosTp600::CheckNthFixL(const TPositionInfo& aPosInfo, const TCoordinate* aFixes, TInt aIndex)

	{

	_LIT(KErrIncorrectFix, "Retrieved fix more than 1 metre away from fix in data file.");

	TPosition pos;

	aPosInfo.GetPosition(pos);

	TReal32 distance;

	pos.Distance(aFixes[aIndex], distance);

	if (distance >= 1)

		{

		LogErrorAndLeaveL(KErrIncorrectFix);

		}

	}

void CT_LbsSimulationPsyPosTp600::GetDistanceL(const TRequestStatus& aStatus, const TPositionInfo& aPosInfo, TReal32& aDistance)

	{

	const TCoordinate KStartingPosition(78.3385, 56.3385);	

	if (aStatus != KRequestPending)

		{

		TPosition pos;

		aPosInfo.GetPosition(pos);

		pos.Distance(KStartingPosition, aDistance);

		}

	}

void CT_LbsSimulationPsyPosTp600::GetDistanceL(const TPositionRequest& aRequest, TReal32& aDistance)

	{

	GetDistanceL(aRequest.iStatus, aRequest.iPositionInfo, aDistance);

	}

void CT_LbsSimulationPsyPosTp600::CheckRequestTimeL(const TRequestStatus& aStatus, TInt aDelta, TBool aFirst, TInt aExpected)

	{

	_LIT(KError, "Tracking time incorrect");

	if (aStatus != KRequestPending &&

		!aFirst && 

		(aDelta > aExpected + KTrackingError))

		{

		LogErrorAndLeaveL(KError);

		}

	}

/*

 * The method sets new Data Mode value and stores it in central repository.

 * @param aCommonDataSet value to be set in central repository.

 */

void CT_LbsSimulationPsyPosTp600::SetCommonDataSetL(const TBool aCommonDataSet) const

	{

	TInt commonDataSet;

	if (aCommonDataSet)

		{

		commonDataSet = 1; // Common Data Set is enabled

		}

	else

		{

		commonDataSet = 0;

		}

	// Set Common Data Set behaviour in the Central Repository

	CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

	User::LeaveIfError(repository-> Set(KCRKeySimPSYCommonDataSet,

			commonDataSet));

	CleanupStack::PopAndDestroy(repository);

	}

/*

 * The method gets Data Mote value from central repository.

 * @param aCommonDataSet value read from central repository.

 */

void CT_LbsSimulationPsyPosTp600::GetCommonDataSetL(TInt& aTrpMode) const

	{

	// Get the Common Data Set setting from Central Repository

	CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

	User::LeaveIfError(repository->Get(KCRKeySimPSYCommonDataSet, aTrpMode));

	CleanupStack::PopAndDestroy(repository);

	}

/*

 * The method opens two positioners. First (iPositioner) one is taken from the base class. 

 * They are expected to be constructed but not opened.

 * @param aPositioner additional positioner which needs to be opened. Requestor is set for it.

 * 			CleanupClosePushL() is used to push aPositioner onto the cleanup stack.

 */

void CT_LbsSimulationPsyPosTp600::OpenPositionersLC(RPositioner& aPositioner)

	{

	TInt err;

	INFO_PRINTF1(_L("Opening first positioner"));

	User::LeaveIfError(OpenPositionerByName(iUidSimulationPsy));

	INFO_PRINTF1(_L("Opening second positioner"));

	err = aPositioner.Open(iPosServer, iUidSimulationPsy);

	User::LeaveIfError(err);

	CleanupClosePushL(aPositioner);

	err = aPositioner.SetRequestor(CRequestor::ERequestorService,

			CRequestor::EFormatApplication, KService);

	if (err != KErrNone)

		{

		_LIT(KErrRequestor, "Error when setting requestor.");

		LogErrorAndLeaveL(KErrRequestor, err);

		}

	}

CT_LbsSimulationPsyPosTp600::TPositionRequest::TPositionRequest(RPositioner& aPositioner) :

	iPositioner(aPositioner)

	{

	}

CT_LbsSimulationPsyPosTp600::TPositionRequest::~TPositionRequest()

	{

	if (iStatus == KRequestPending)

		{

		iPositioner.CancelRequest(EPositionerNotifyPositionUpdate);

		}

	}

void CT_LbsSimulationPsyPosTp600::TPositionRequest::MakeRequestL()

	{

	if (iStatus != KRequestPending)

		{

		iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);

		iRequestTime.UniversalTime();

		}	

	}