// 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 "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 ctlbsclientsteppartialupdate.cpp

// This is the class implementation for the UpdateOptions Tests

// 

//

#include "ctlbsclientsteppartialupdate.h"

#include <lbs.h>

#include <lbssatellite.h>

#include "tlbsutils.h"

#include "ctlbsasyncwaiter.h"

#define EXPECTED_GPS_ACCURACY_HORIZONTAL 20

#define EXPECTED_GPS_ACCURACY_VERTICAL 20

#define KLbsKeepAlivePeriod 		10000

#define REFPOS_LAT				2

#define REFPOS_LONG				3

#define REFPOS_ALT				10

#define REFPOS_HORZ_ACCURACY	100

#define REFPOS_VERT_ACCURACY	100

#define REFPOS_HORZ_ACCURACY_BETTER	5

#define REFPOS_VERT_ACCURACY_BETTER	5

const TInt KTestAssistanceDataProviderPluginUidValue = 0x10281D77;

const TInt KRealAssistanceDataProviderPluginUidValue = 0x1028225B;

/**

 * Destructor

 */

CT_LbsClientStep_PartialUpdate::~CT_LbsClientStep_PartialUpdate()

	{

	delete iDoPosUpdatePtr;

	}

/**

 * Constructor

 */

CT_LbsClientStep_PartialUpdate::CT_LbsClientStep_PartialUpdate(CT_LbsClientServer& aParent) : CT_LbsNetSimStep(), iParent(aParent)

	{

	SetTestStepName(KLbsClientStep_PartialUpdate);

	}

/**

Static Constructor

*/

CT_LbsClientStep_PartialUpdate* CT_LbsClientStep_PartialUpdate::New(CT_LbsClientServer& aParent)

	{

	// Note the lack of ELeave.

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

	CT_LbsClientStep_PartialUpdate* testStep = new CT_LbsClientStep_PartialUpdate(aParent);

	if (testStep)

		{

		TInt err = KErrNone;

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

		if (err)

			{

			delete testStep;

			testStep = NULL;

			}

		}

	return testStep;

	}	

void CT_LbsClientStep_PartialUpdate::ConstructL()

	{

	// Create the base class objects.

    CT_LbsNetSimStep::ConstructL();

	// and the active object wrapper for the notify position update.

	iDoPosUpdatePtr = CT_LbsDoPosUpdate::NewL(this, TPositionModuleInfo::ETechnologyTerminal);

	}

/**

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

	{

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

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

	if (TestStepResult()==EPass) 

		{

		TInt err = KErrNone;

		iPosUpdateStatus = EPositionUpdateStart;

		//Configure partial Updates

		TPositionUpdateOptions optsA;

		optsA.SetAcceptPartialUpdates(ETrue);

		if(!optsA.AcceptPartialUpdates())

			{

			INFO_PRINTF1(_L("Partial Updates not set."));

			SetTestStepResult(EFail);

			}	

		err = iDoPosUpdatePtr->SetOptions(optsA);

		User::LeaveIfError(err);

		CLbsAdmin* lbsAdminApi = CLbsAdmin::NewL();

		CleanupStack::PushL(lbsAdminApi);

		// Carryout unique test actions.

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

			{

				switch (iTestCaseId)

				{

				// Test case LBS-Partial-Update-Options-0001

				case 1:

					{

					CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsAutonomous;

					lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);

					//Configure Partial Update to EFalse

					TPositionUpdateOptions updOpts;

					updOpts.SetUpdateTimeOut(10*1000000);

					updOpts.SetAcceptPartialUpdates(EFalse);

					if(EFalse != updOpts.AcceptPartialUpdates())

						{

						INFO_PRINTF1(_L("Partial Updates not set."));

						SetTestStepResult(EFail);

						}	

					err = iDoPosUpdatePtr->SetOptions(updOpts);

					User::LeaveIfError(err);

					break;

					}

				// Test case LBS-Partial-Update-Options-0002

				case 2:

				case 3:

				case 4:

				case 5:

				case 6:

				case 7:

					{

					CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsAutonomous;

					lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);

					break;

					}

				case 21:

				case 22:

				case 24:

				case 25:

				case 26:

					{

					CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsPreferTerminalBased;

					lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);

					break;

					}

				case 23:

					{

					CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsPreferTerminalBased;

					lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);

					//Configure Partial Update to EFalse

					TPositionUpdateOptions updOpts;

					updOpts.SetAcceptPartialUpdates(EFalse);

					if(EFalse != updOpts.AcceptPartialUpdates())

						{

						INFO_PRINTF1(_L("Partial Updates not set."));

						SetTestStepResult(EFail);

						}	

					err = iDoPosUpdatePtr->SetOptions(updOpts);

					User::LeaveIfError(err);

					break;

					}

				case 27:

				case 28:

					{

					//Tracking

					CLbsAdmin::TGpsMode gpsMode;

					if(iTestCaseId == 27)

						{

						gpsMode = CLbsAdmin::EGpsAutonomous;

						}

					else

						{

						gpsMode = CLbsAdmin::EGpsPreferTerminalBased;

						}

					lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);

					TPositionUpdateOptions updOpts;

					updOpts.SetUpdateInterval(10*1000000); //Set Update Interval to 10 secs

					updOpts.SetAcceptPartialUpdates(ETrue);

					err = iDoPosUpdatePtr->SetOptions(updOpts);

					User::LeaveIfError(err);

					break;

					}

				default:

					User::Panic(KLbsClientStep_PartialUpdate, KErrUnknown);					

					}

				}

		User::LeaveIfError(OpenNetSim());

		// Kick off the test abort and keep alive timers.

		TTimeIntervalMicroSeconds32 keepAliveInterval(KLbsKeepAlivePeriod);

		iKeepAliveTimer->SetTimer(keepAliveInterval);

		// Kick off test.

		CActiveScheduler::Start();

		// Verify location data.

		VerifyPosInfos();

		//Reset Test module timeout

		TModuleDataIn modDataIn; 

		modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

		modDataIn.iTimeOut = 0;

		T_LbsUtils utils;

		utils.NotifyModuleOfConfigChangeL(modDataIn);

		// Clean up.

		CloseNetSim();

		CleanupStack::PopAndDestroy(lbsAdminApi);

		}

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

	return TestStepResult();

	}

void CT_LbsClientStep_PartialUpdate::Connected()

	{

	// Call base implementation.

	//CT_LbsNetSimStep::Connected();

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

	T_LbsUtils utils;

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

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

	iPosInfoPtr1 = new(ELeave) TPositionInfo();

	posInfoArr.Append(iPosInfoPtr1);

	iPosInfoPtr2 = new(ELeave) TPositionInfo();

	posInfoArr.Append(iPosInfoPtr2);

	//For test case 22, Set Reference Position better than required position

	if(iTestCaseId == 22)

		{

		// Set the reference position, which also be used for any required verification.

		iRefPos.SetCoordinate(REFPOS_LAT, REFPOS_LONG, REFPOS_ALT);

		iRefPos.SetAccuracy(REFPOS_HORZ_ACCURACY_BETTER, REFPOS_VERT_ACCURACY_BETTER);

		iRefPos.SetCurrentTime();

		if (!iNetSim.SetReferenceLocation(iRefPos))

			{

			INFO_PRINTF1(_L("Failed test, can't set NetSim's reference location."));

			SetTestStepResult(EFail);

			}	

		}

	// Kick off pos update.

	iDoPosUpdatePtr->StartL(*iPosInfoPtr1);

	}

void CT_LbsClientStep_PartialUpdate::MT_LbsDoPosUpdateCallback(TRequestStatus& aStatus)

	{

	INFO_PRINTF1(_L("Got - Client Notify Update Complete - Callback Event."));

	T_LbsUtils utils;

	TInt err = aStatus.Int();

	switch(iTestCaseId)

		{

		case 1:

			{

			if (KPositionQualityLoss != err)

				{

				SetTestStepResult(EFail);

				}

			iState = EWaiting;

			break;

			}

		case 2:

		case 3:

			{

			if (KPositionPartialUpdate != err)

				{

				SetTestStepResult(EFail);

				}	

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				// Kick off pos update.

				iDoPosUpdatePtr->StartL(*iPosInfoPtr2);

				iPosUpdateStatus = EPositionUpdateComplete;				

				}

			else

				iState = EWaiting;

			break;

			}

		case 4:

			{

			if (KErrNone != err)

				{

				SetTestStepResult(EFail);

				}	

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				// Kick off pos update.

				iDoPosUpdatePtr->StartL(*iPosInfoPtr2);

				iPosUpdateStatus = EPositionUpdateComplete;				

				}

			else

				iState = EWaiting;

			break;

			}

		case 5:

		case 6:

		case 21:

		case 22:

			{

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				if(iTestCaseId == 5 || iTestCaseId == 21)

					{

					if (KPositionPartialUpdate != err)

						{

						SetTestStepResult(EFail);

						}	

					}

				else

					{

					if (KErrNone != err)

						{

						SetTestStepResult(EFail);

						}	

					}

				}

			else

				{

				if (KPositionEarlyComplete != err)

					{

					SetTestStepResult(EFail);

					}	

				}

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				TModuleDataIn modDataIn; // Used to send test information to the test module.

				modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

				modDataIn.iTimeOut = 5*1000000;

				// Send timeout value to test module - will block.

				utils.NotifyModuleOfConfigChangeL(modDataIn);

				// Kick off pos update.

				iDoPosUpdatePtr->StartL(*iPosInfoPtr2);

				err = iDoPosUpdatePtr->CompleteRequest(EPositionerNotifyPositionUpdate);

				if (err != KErrNone)

					{

					SetTestStepResult(EFail);

					}	

				iPosUpdateStatus = EPositionUpdateComplete;				

				}

			else

				{

				//if(iTestCaseId == 5 || iTestCaseId == 6)

					{

					iState = EWaiting;	

					}

				}

			break;

			}

		case 7:

			{

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				if (KPositionPartialUpdate != err)

					{

					SetTestStepResult(EFail);

					}	

				// Kick off pos update.

				iDoPosUpdatePtr->StartL(*iPosInfoPtr2);

				iPosUpdateStatus = EPositionUpdateComplete;				

				}

			else

				{

				if (KErrNone != err)

					{

					SetTestStepResult(EFail);

					}	

				err = iDoPosUpdatePtr->CompleteRequest(EPositionerNotifyPositionUpdate);

				if (err != KErrNotFound)

					{

					SetTestStepResult(EFail);

					}	

				iState = EWaiting;	

				}

			break;

			}			

		case 23:

			{

			if (KErrNone != err)

				{

				SetTestStepResult(EFail);

				}	

			break;

			}

		case 24:

		case 27:

			{

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				if (KPositionPartialUpdate != err)

					{

					SetTestStepResult(EFail);

					}

				if(iPosUpdateStatus == EPositionUpdateStart)

					{

					iDoPosUpdatePtr->StartL(*iPosInfoPtr2);

					iPosUpdateStatus = EPositionUpdateContinue;

					}

				else

					{

					TModuleDataIn modDataIn; // Used to send test information to the test module.

					modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

					modDataIn.iTimeOut = 5*1000000;

					// Send timeout value to test module - will block.

					utils.NotifyModuleOfConfigChangeL(modDataIn);

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

					TPositionInfo* posInfoPtr3;

					posInfoPtr3 = new(ELeave) TPositionInfo();

					posInfoArr.Append(posInfoPtr3);

					// Kick off pos update.

					iDoPosUpdatePtr->StartL(*posInfoPtr3);

					err = iDoPosUpdatePtr->CompleteRequest(EPositionerNotifyPositionUpdate);

					if (err != KErrNone)

						{

						SetTestStepResult(EFail);

						}	

					iPosUpdateStatus = EPositionUpdateComplete;				

					}

				}

			else

				{

				if (KPositionEarlyComplete != err)

					{

					SetTestStepResult(EFail);

					}	

				//if (iTestCaseId == 27)

				//	{

					iState = EWaiting;

				//	}	

				}

			break;

			}

		case 25:

		case 26:

			{

			if(iPosUpdateStatus != EPositionUpdateComplete)

				{

				if (KPositionPartialUpdate != err)

					{

					SetTestStepResult(EFail);