// 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 ctlbsclientstep_notifyposupdate.cpp

// This is the class implementation for the Notify Position Update Tests

// 

//

#include "ctlbsclientstepnotifyposupdate.h"

#include <lbs.h>

#include <lbssatellite.h>

#include "tlbsutils.h"

#include "ctlbsasyncwaiter.h"

// constant definitions

_LIT(KLbsClientStepNotifyPosUpdate, "LbsClientStepNotifyPosUpdate");

//profile_id in ini file

_LIT(KLbsProfileId, "profile_id");

//max_time in ini file

_LIT(KLbsMaxTime, "max_time");

const TTimeIntervalMicroSeconds KModuleTimeout = 6000000;//makes test module time out(which should be more than the Maxtime in lbsprofile.ini)

/**

 *	Sets a Requestor for now - TODO will be removed with new location server

 */

void CT_LbsClientStep_NotifyPosUpdate::TempSetRequestorL()

 	{	

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

												CRequestor::EFormatApplication,

												_L("Tom Tom")));

 	}

/**

 * Destructor

 */

CT_LbsClientStep_NotifyPosUpdate::~CT_LbsClientStep_NotifyPosUpdate()

	{

	delete 	iLbsAdmin;	

	}

/**

 * Constructor

 */

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

	{

	SetTestStepName(KLbsClientStep_NotifyPosUpdate);

	}

/**

Static Constructor

*/

CT_LbsClientStep_NotifyPosUpdate* CT_LbsClientStep_NotifyPosUpdate::New(CT_LbsClientServer& aParent)

	{

	// Note the lack of ELeave.

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

	CT_LbsClientStep_NotifyPosUpdate* testStep = new CT_LbsClientStep_NotifyPosUpdate(aParent);

	if (testStep)

		{

		TInt err = KErrNone;

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

		if (err)

			{

			delete testStep;

			testStep = NULL;

			}

		}

	return testStep;

	}

void CT_LbsClientStep_NotifyPosUpdate::ConstructL()

	{

	// create the admin

	iLbsAdmin = CLbsAdmin::NewL();

	}

//from MT_NotifyPosUpdateObserver:

/**

 * 	Callback - called when NotifyPositionUpdate request completes

 */

void CT_LbsClientStep_NotifyPosUpdate::NotifyPositionUpdateCallback(TRequestStatus& aStatus)

	{

	TInt err = aStatus.Int();

	if (KErrCancel != err)	

		{

		SetTestStepResult(EFail); // the request always gets cancelled (see test 0122)

		}

	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_LbsClientStep_NotifyPosUpdate::doTestStepL()

	{

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

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

	if (TestStepResult()==EPass)

		{

		TInt err = KErrNone;

		// Connect to self locate server.

		err = iServer.Connect();

		User::LeaveIfError(err);

		CleanupClosePushL(iServer);

		// Carryout unique test actions.

		TInt testCaseId;

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

			{

				switch (testCaseId)

				{

				// Test case LBS-NotifyPosUpdate-0001

				case 1:

				case 29: // Test case LBS-NotifyPosUpdate-0029

				case 30: // Test case LBS-NotifyPosUpdate-0030

				case 101:

				case 105:

				case 201: // in Lbs "original" mode no ref position!	

					{

					T_LbsUtils utils;

					// Open positioner.

					err = iPositioner.Open(iServer);

					User::LeaveIfError(err);

					CleanupClosePushL(iPositioner);

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

					if ((testCaseId == 101) || (testCaseId == 105))

						{

						if (testCaseId == 105)

							{	

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

							modDataIn.iRequestType = TModuleDataIn::EModuleRequestTestMode;

							modDataIn.iAssDataTestMode = TModuleDataIn::EModuleTestModeAssDataOn_EarlyPosUpdates;

							// Inform the test module of the required test mode - will block.

							utils.NotifyModuleOfConfigChangeL(modDataIn);

							}

						// 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.

						TPositionInfo verifyRefPosInfo;

						verifyRefPosInfo.SetPosition(iRefPos);

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

							{

							if(!iParent.iSharedData->iTestModuleInUse)

								{

								WARN_PRINTF1(_L("WARNING: position received was not reference position"));	

								}

							else

								{	

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

								SetTestStepResult(EFail);

								}

							}

						}

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

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

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

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

					posInfoArr.Append(posInfo);

					// Get the actual position

					err = DoNotifyUpdateL(*posInfo);

					if (KErrNone != err)

						{

						SetTestStepResult(EFail);

						}

					// Cleanup.

					CleanupStack::PopAndDestroy(&iPositioner);

					if ((testCaseId == 101) || (testCaseId == 105))

						{

						CloseNetSim();

						}

					break;

					}

				// Test case LBS-NotifyPosUpdate-0003		

				case 3:

					{

					// Select the Network module because it does not support TPositionSatelliteInfo,

					// then request position update and expect satellite info, which should return

					// in KErrArgument.

					TPositionModuleId	modId;

					T_LbsUtils utils;

					modId = utils.GetNetworkModuleIdL(iServer);

					// Select the network module.

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

					CleanupClosePushL(iPositioner);

					// Try to get the actual position, using TPositionSatellite which is not

					// supported by the selected module.

					TPositionSatelliteInfo posInfo;

					err = DoNotifyUpdateL(posInfo);

					if (KErrArgument == err)

						{

						INFO_PRINTF2(_L("correct err %d returned"), err);

						}

					else

						{

						INFO_PRINTF2(_L("incorrect err %d returned"), err);

						SetTestStepResult(EFail);

						}						

					CleanupStack::PopAndDestroy(&iPositioner);

					break;

					}

				// Test case LBS-NotifyPosUpdate-0005						

				case 5:	

					{

					CLbsAdmin::TSelfLocateService selflocate;

					User::LeaveIfError(iLbsAdmin->Set(KLbsSettingHomeSelfLocate, CLbsAdmin::ESelfLocateOff));

					User::LeaveIfError(iLbsAdmin->Get(KLbsSettingHomeSelfLocate, selflocate));

					if(selflocate != CLbsAdmin::ESelfLocateOff)

						{

						SetTestStepResult(EFail);

						}

					else

						{

						// Open positioner.

						err = iPositioner.Open(iServer);

						User::LeaveIfError(err);

						CleanupClosePushL(iPositioner);

						TPositionInfo notifyPosInfo;

						err = DoNotifyUpdateL(notifyPosInfo);

						if(KErrAccessDenied != err)

							{

							SetTestStepResult(EFail);

							}

						}

					User::LeaveIfError(iLbsAdmin->Set(KLbsSettingHomeSelfLocate, CLbsAdmin::ESelfLocateOn));

				    CleanupStack::PopAndDestroy(&iPositioner);

					}

					break;

				// Test case LBS-NotifyPosUpdate-0006	

				case 6:	

					{

					// Open positioner.

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

					CleanupClosePushL(iPositioner);

					TPositionInfo posInfoNotifyUpd;

					TRequestStatus status;

					TBool cancelled;

					TempSetRequestorL();

					iPositioner.NotifyPositionUpdate(posInfoNotifyUpd, status);

					TInt err = iPositioner.CancelRequest(EPositionerNotifyPositionUpdate);

					if(KErrNone == err)

						{

							cancelled = TRUE;

						}

					else

						{

							cancelled = FALSE;

						}

					// this should complete with either KErrNone or KErrCancel

					User::WaitForRequest(status);

					err = status.Int();

					if(cancelled)

						{

						if((KErrCancel != err) && (KErrNone != err))

							{

							SetTestStepResult(EFail); 

							}

						}

					else

						{

						if(KErrNone != err)

							{

							SetTestStepResult(EFail);

							}

						}

					CleanupStack::PopAndDestroy(&iPositioner);					

					}

					break;

			  	// Test case LBS-NotifyPosUpdate-0007

				case 7:

					{

					// Note: Not connecting to position server.

					TPositionInfo notifyPosInfo;

					TRequestStatus status;

					// should panic with EPositionServerBadHandle 

					iPositioner.NotifyPositionUpdate(notifyPosInfo, status);

					}

					break;

				// Test case LBS-NotifyPosUpdate-0008

				case 8:	

					{

					// Open positioner.

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

					CleanupClosePushL(iPositioner);

					TPositionInfo notifyPosInfo, notifyPosInfo2;

					TRequestStatus status, status2;

					TempSetRequestorL();

					// attempt multiple NotifyPositionUpdates on same subsession:

					iPositioner.NotifyPositionUpdate(notifyPosInfo, status);

					// expected to panic with EPositionDuplicateRequest:

					iPositioner.NotifyPositionUpdate(notifyPosInfo2, status2);

					// need to block here so that loc server can run and recieve both

					// requests - its the second request that causes the panic!

					User::After(1);

					// if we get here, we've failed to panic

					SetTestStepResult(EFail);

					CleanupStack::PopAndDestroy(&iPositioner);					

					}

					break;						

				// Test case LBS-NotifyPosUpdate-0014	INCOMPLETE

				case 14:

					{

					// Set 'autonomous' mode

					CLbsAdmin::TGpsMode mode;

					User::LeaveIfError(iLbsAdmin->Set(KLbsSettingHomeGpsMode, CLbsAdmin::EGpsAutonomous));

					User::LeaveIfError(iLbsAdmin->Get(KLbsSettingHomeGpsMode, mode));

					// TODO: figure out how to get notifications of assistance data requests (MLbsNetSimTestObserver?)

					// If we get notification before Notify Update completes, then we fail

					if(mode != CLbsAdmin::EGpsAutonomous)

						{

						SetTestStepResult(EFail);

						}

					else	// Request a location update

						{

						// Open positioner.

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

						CleanupClosePushL(iPositioner);

						// Create a posinfos 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.

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

						posInfoArr.Append(posInfoNotifyUpd);

						err = DoNotifyUpdateL(*posInfoNotifyUpd);

						if (KErrNone != err)

							{

							SetTestStepResult(EFail);

							}

						CleanupStack::PopAndDestroy(&iPositioner);

						}

					}

					break;

				// Test case LBS-NotifyPosUpdate-0015	UNSUPPORTED

				case 15:

					{

					// this test should not be run; lbs currently doesn't support AlwaysTerminalBased mode

					__ASSERT_ALWAYS(FALSE, User::Panic(_L("LBS-NotifyPosUpdate-0015 should not be run"), KErrNotSupported));					

					// Set 'assisted-only' (EGpsAlwaysTerminalBased) mode

					CLbsAdmin::TGpsMode mode;

					User::LeaveIfError(iLbsAdmin->Set(KLbsSettingHomeGpsMode, CLbsAdmin::EGpsAlwaysTerminalBased));

					User::LeaveIfError(iLbsAdmin->Get(KLbsSettingHomeGpsMode, mode));

					// TODO: figure out how to get notifications of assistance data requests (MLbsNetSimTestObserver?)

					// If we do not get notification before Notify Update completes, then we fail

					if(mode != CLbsAdmin::EGpsAlwaysTerminalBased)

						{

						SetTestStepResult(EFail);

						}

					else	// Request a location update

						{

						// Open positioner.

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

						CleanupClosePushL(iPositioner);

						// Create a posinfos 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.

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

						posInfoArr.Append(posInfoNotifyUpd);

						err = DoNotifyUpdateL(*posInfoNotifyUpd);	// can use this blocking version if netsim uses callbacks for assistance data notifications

						// TODO iRequestedAssData needs to be set in assist data callback

						if (KErrNone != err || !iRequestedAssData || !iReceivedAssData)

							{

							SetTestStepResult(EFail);

							}

						// verify that preferred positioning mode was used:

						if(EPositionModeReasonNone != posInfoNotifyUpd->PositionMode())

							{

							SetTestStepResult(EFail);

							}

						CleanupStack::PopAndDestroy(&iPositioner);

						}

					}

					break;

				// Test case LBS-NotifyPosUpdate-0016	INCOMPLETE

				case 16:

					{

					// Set 'assisted-if-possible' (EGpsPreferTerminalBased) mode

					CLbsAdmin::TGpsMode mode;

					User::LeaveIfError(iLbsAdmin->Set(KLbsSettingHomeGpsMode, CLbsAdmin::EGpsPreferTerminalBased));

					User::LeaveIfError(iLbsAdmin->Get(KLbsSettingHomeGpsMode, mode));

					#pragma message("TO DO: LBS-NotifyPosUpdate-0016	INCOMPLETE")					

					// figure out how to get notifications of assistance data requests (MLbsNetSimTestObserver?)

					// If we do not get notification before Notify Update completes, then we fail

					// do we need to do something to make sure that we require assistancce data (no assistance data already retrieved)?

					// Configure NetSim to indciate that network is not available

					if(mode != CLbsAdmin::EGpsPreferTerminalBased)

						{

						SetTestStepResult(EFail);

						}

					else	// Request a location update

						{

						// Open positioner.

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

						CleanupClosePushL(iPositioner);

						// Create a posinfos 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.

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

						posInfoArr.Append(posInfoNotifyUpd);

						err = DoNotifyUpdateL(*posInfoNotifyUpd);	// can use this blocking version if netsim uses callbacks for assistance data notifications

						if (KErrNone != err || !iRequestedAssData)

							{

							SetTestStepResult(EFail);