// 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 "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:

// @file ctlbsclockstepmain.cpp

// This is the class implementation for the Clock Tests

// EPOC includes.

// LBS includes. 

// 

//

// LBS test includes.

#include "ctlbsclockstepmain.h"

const TTimeIntervalMicroSeconds32 KVerifyTimerInterval = 250000;//0.25s

const TTimeIntervalMicroSeconds KDefaultAdjustClockTimeout = 3000000;

const TTimeIntervalMicroSeconds KModuleTimeout = 50 * 1000* 1000;

const TInt64 KMaxDiffForRoughCompare = 5000000;

const TInt64 KMaxDiffForExactCompare = 2000000;

const TInt64 KMaxDiffForTimeoutCompare = 500000;

const TVersion verifyVer(1,0,0);

_LIT(KTimeOffset, "time_offset");

_LIT(KClientTimeout, "client_timeout");

/** When adding new tests try to follow the test execute path currently taken by existing tests.

A typical test case follows this logic flow though the code:

doTestStepL() is called, where the required clock admin is set, which in turn causes the admin notification function

OnSettingUpdateEvent() to be called, from which the test starts (some tests will end here also).

Then from OnSettingUpdateEvent() a async operation is fired, which results in the RunL() being called, from here the test will

come to a end or continue with a further cycle of RunL().

During the test CheckForTestHalt() will be called to determine is the test has finished, which done as a result of

the correct test flags being set.

*/

/**

Static Constructor

*/

CT_LbsClockStep_Main* CT_LbsClockStep_Main::New(CT_LbsClockServer& aParent)

	{

	// Note the lack of ELeave.

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

	CT_LbsClockStep_Main* testStep = new CT_LbsClockStep_Main(aParent);

	if (testStep)

		{

		TInt err = KErrNone;

		TRAP(err, testStep->ConstructL());

		if (err)

			{

			delete testStep;

			testStep = NULL;

			}

		}

	return testStep;

	}

/**

 * Constructor

 */

CT_LbsClockStep_Main::CT_LbsClockStep_Main(CT_LbsClockServer& aParent) : CT_LbsClockStep(aParent), CActive(CActive::EPriorityStandard)

	{

	SetTestStepName(KLbsClockStep_Main);

	}

void CT_LbsClockStep_Main::ConstructL()

	{

	// Create the base class objects.

	CT_LbsClockStep::ConstructL();

	// Connect to the LBS self locate server.

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

	CleanupClosePushL(iServer);

	// Open the positioner.

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

	CleanupClosePushL(iPositioner);

	// set requester will be removed...

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

													CRequestor::EFormatApplication,

													_L("Tom Tom")));

	// Create the admin.

	iAdmin = CLbsAdmin::NewL(*this);

	// Create the verify timer.

	iVerifyTimer = CT_LbsTimerUtils::NewL(this, 0);

	// Create the plugin data bus monitor.

	iPluginDataBusMonitor = CT_LbsClockPluginDataBusMonitor::NewL(this);

	// Determine the A-GPS module's time to first fix.

	DetermineModuleTimeToFirstFixL();

	CActiveScheduler::Add(this);

	CleanupStack::Pop(&iPositioner);

	CleanupStack::Pop(&iServer);

	}

/**

 * Destructor

 */

CT_LbsClockStep_Main::~CT_LbsClockStep_Main()

	{

	Cancel();

	iVerifyTimer->CancelTimer();

	iPluginDataBusMonitor->CancelMonitor();

	delete iPluginDataBusMonitor;

	delete iVerifyTimer;

	delete iAdmin;

	iPositioner.Close();

	iServer.Close();	

	}

/** Used to mark each callback that has fired.

*/

void CT_LbsClockStep_Main::SetCallbackFlag(TLbsClockCallbackFlags aCallbackFlag)

	{

	iCallbackFlags |= aCallbackFlag;

	}

/** Determine the end of the test.

	Check the state machine to determine when to halt the test. Once all the callbacks

	have been received the test can end.

*/

void CT_LbsClockStep_Main::CheckForTestHalt()

	{

	// Check for test finish.

	// We stop test from here when in the correct state and, there should not be anything outstanding.

	if ((iState == EWaiting) && (iCallbackFlags == iFlagsToHaltOn))

		{

		iState = EDone;

		iPluginDataBusMonitor->CancelMonitor();

		CActiveScheduler::Stop();

		}

	}

/**

 * @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_LbsClockStep_Main::doTestStepL()

	{

	// Generic test step used to test the LBS Client Notify position update API.

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

	RDebug::Printf(">> CT_LbsClockStep_Main::doTestStepL()");

	if (TestStepResult() == EPass)

		{		

		// Carry out common test actions (such as connecting to a server).

		// Ensure auto adjust is off.

		User::LeaveIfError(iAdmin->Set(KLbsSettingClockAdjust, CLbsAdmin::EClockAdjustOff));

		// Only interested in clock related admin changes.

		iAdmin->SetNotificationMaskL(KLbsSettingClockAdjust | KLbsSettingAllowManualClockAdjust);

		iState = EWaitingAdminNotify;

		// Netsim setup is required if the AGPS module is in the EGpsPreferTerminalBased mode.

		TBool iNetSimUsed = EFalse;

		CLbsAdmin::TGpsMode modAgpsMode;

		User::LeaveIfError(iAdmin->Get(KLbsSettingHomeGpsMode, modAgpsMode));

		if (modAgpsMode == CLbsAdmin::EGpsPreferTerminalBased)

			{

			iNetSimUsed = ETrue;

			OpenNetSim();

			}

		// Carry out unique test actions.

		if (GetIntFromConfig(ConfigSection(), KTestCaseId, iTestCaseId))

			{

			switch (iTestCaseId)

				{

				// test case LBS-SetTime-0002 - man

				case 2:

					{

					iFlagsToHaltOn =	KLbsClockCallback_Got_AdjustClock_Stage1 |

										KLbsClockCallback_Got_AdminNotification;

					User::LeaveIfError(iAdmin->Set(KLbsSettingAllowManualClockAdjust, CLbsAdmin::EClockAdjustOff));

					}

					break;

				// Test case LBS-Clock-0004 - man

				case 12:

				case 13:

					{

					iFlagsToHaltOn =	KLbsClockCallback_Got_AdjustClock_Stage1 |

										KLbsClockCallback_Got_AdjustClock_Stage2 |

										KLbsClockCallback_Got_AdminNotification;

					// Set time stamp offset, how much to alter the clock by.

					SetTimeOffsetL();	// This will block if test module is in use.

					// Switch on auto adjust.

					if (iTestCaseId == 13)

						{

						SetAutoAdjustOnL();

						}

					// Switch on the Clock API Kick off both the admin change

					User::LeaveIfError(iAdmin->Set(KLbsSettingAllowManualClockAdjust, CLbsAdmin::EClockAdjustOn));

					}

					break;

				// will timeout

				case 18:

				case 19:

					{

					iFlagsToHaltOn =	KLbsClockCallback_Got_AdjustClock_Stage1 |

										KLbsClockCallback_Got_AdminNotification;

					// Set time stamp offset, how much to alter the clock by.

					SetTimeOffsetL();	// This will block if test module is in use.

					// Set the module timeout to ensure the clock adjust does timeout.

					if ((iTestCaseId == 18) || (iTestCaseId == 19))

						{

						SetModuleTimeoutL(KModuleTimeout); 	// This will block.

						}

					// Switch on the Clock APIKick off both the admin change

					User::LeaveIfError(iAdmin->Set(KLbsSettingAllowManualClockAdjust, CLbsAdmin::EClockAdjustOn));

					}

					break;

				// Test case LBS-Clock-0020 - auto

				case 20:

				case 21:

				case 41:

					{

					StartAutoAdjustTesting();

					}

					break;

				case 121:

					{

					// Soak up the network position info generated when assistance data is requested

					// by the AGPS module.

					iState = ESoakRefPos;

					iPositioner.NotifyPositionUpdate(iRefPosInfo, iStatus);

					SetActive();

					}

					break;

				default:

					{

					User::Panic(KLbsClockStep_Main, KErrUnknown);

					}					

				}

			}

		// Kick off test.

		CActiveScheduler::Start();

		// Close Netsim if used by test.

		if (iNetSimUsed)

			{

			CloseNetSim();

			}

		}

	INFO_PRINTF1(_L("<< CT_LbsClockStep_Main::doTestStepL()"));

	return TestStepResult();

	}

void CT_LbsClockStep_Main::DoCancel()

	{

	}

void CT_LbsClockStep_Main::OnSettingUpdateEvent(TInt aError, const TLbsAdminSetting& aSetting)

	{

	// Only process the notifications we requested.

	if (iState == EWaitingAdminNotify)

	{

		// Only process the clock setting.

		if ((KLbsSettingClockAdjust == aSetting) || (KLbsSettingAllowManualClockAdjust == aSetting))

			{

			SetCallbackFlag(KLbsClockCallback_Got_AdminNotification);

			if (aError)

				{

				// Test failed.

				INFO_PRINTF2(_L("Failed test, admin change failed with error %d."), aError);

				SetTestStepResult(EFail);

				}

			else

				{

				// next stage of the test here - first clock sync

				switch (iTestCaseId)

					{

					case 2:

						{					

						SetActive();

						iState = EClockAdjustPending_Stage1;

						}

						break;

					case 12:

					case 13:

					case 20:

					case 21:

					case 41:

					case 121:

						{

						AdjustClock(EFalse, 0);

						iState = EClockAdjustPending_Stage1;					

						}

						break;

					case 18:

					case 19:

						{

						if (iTestCaseId == 19)

							{

							}

						else

							{

							// Read the client timeout value.

							SetClientTimeout();

							INFO_PRINTF2(_L("AdjustClock(%d)"), iClientTimeout.Int64());

							}

						SetActive();

						iAdjustClockCallTime.UniversalTime();

						iState = EClockAdjustPending_Stage1;

						}

						break;

					default:

						{

						}

					}

				}

			CheckForTestHalt();

			}

		}

	}

void CT_LbsClockStep_Main::RunL()

	{

	TBool errExpected = ETrue;	// Some tests expect an error.

	TInt err = iStatus.Int();

	TTime currentTime;

	INFO_PRINTF2(_L("CT_LbsClockStep_Main::RunL() iTestCaseId=%D"), iTestCaseId);

	// Cancel the verify timer.

	iVerifyTimer->CancelTimer();

	// may not be able to put here - for pos it will be set twice that's all

	SetCallbackFlag(KLbsClockCallback_Got_AdjustClock_Stage1);

	switch (iTestCaseId)

		{

		case 2:

			{

			if (err != KErrLocked)

				{

				// Test failed.

				INFO_PRINTF2(_L("Failed test, expected KErrLocked got error %d."), err);

				SetTestStepResult(EFail);

				}

			iState = EWaiting;

			}

			break;

		case 18:

		case 19:

			{

			// Verify the call timed out after the correct interval.

			switch (iTestCaseId)

				{

				case 18:

					{

					ValidateTimeout(iClientTimeout);

					}

					break;

				case 19:

					{

					ValidateTimeout(iGpsTimeToFirstFix);

					}

					break;

				}

			// Verify error code.

			if (err != KErrTimedOut)

				{

				// Test failed.

				INFO_PRINTF2(_L("Failed test, expected KErrTimedOut got error %d."), err);

				SetTestStepResult(EFail);

				}

			iState = EWaiting;

			}

			break;

		case 13:

		case 20:

		case 21:

		case 41:

		case 121:

			{

			// Special case where the ref pos is soaked up. Only required for test cases 120 + 121.

			if (iState == ESoakRefPos)

				{

				// Verify reference position.

				TPositionInfo verifyRefPosInfo;

				T_LbsUtils utils;

				verifyRefPosInfo.SetPosition(iRefPos);

				// Only verify ref position when using test module. The reason for this

				// is the real module may or may not allways ref pos for new clients.

				if (!utils.Compare_PosInfo(verifyRefPosInfo, iRefPosInfo) &&

					iParent.iSharedData->iTestModuleInUse)

					{

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

					SetTestStepResult(EFail);

					}

				// Errors not expected.

				errExpected = EFalse;

				// Start test in normal way.

				StartAutoAdjustTesting();

				break;

				}

			// Print expected time after AdjustClock.

			INFO_PRINTF1(_L("Expected time after AdjustClock: "));	

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

			// Print the current time after AdjustClock.

			TTime currentTime;

			currentTime.UniversalTime();

			INFO_PRINTF1(_L("Actual time after AdjustClock: "));	

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

			// Errors not expected.

			errExpected = EFalse;

			// System clock updated, verify time was updated correctly.

			if (iState == EClockAdjustPending_Stage1)

				{

				SetCallbackFlag(KLbsClockCallback_Got_AdjustClock_Stage1);

				CompareTimes(T_LbsUtils::ERoughAccuracy);

				// Before next adjust wait a while. To ensure the target time for the second request is always different from the first request.

				// There is a very small chance that the target times for the update request are the same, this is due to the clock being adjusted to precily

				// the same time as it was before the first request.

				User::After(3000000);

				AdjustClock(EFalse, 0);

				iState = EClockAdjustPending_Stage2;

				}

			else if (iState == EClockAdjustPending_Stage2)

				{

				SetCallbackFlag(KLbsClockCallback_Got_AdjustClock_Stage2);

				CompareTimes(T_LbsUtils::EExactAccuracy);

				iState = EWaiting;

				}

			}

			break;

		}

	// Check if the test is over.	

	CheckForTestHalt();

	// Report any un-expected errors.

	if (!errExpected && err)

		{

		User::LeaveIfError(err);

		}

	}