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

//

//************************************************************************************************************

// System

#include <bacline.h>

#include <e32cons.h>

#include <ecom/ecom.h> 

// Project

#include "lbsmanagermainlogic.h"

#include "lbstimer.h"

#include <lbs.h>

#include <lbs/lbsassistancedatabase.h>

#include <lbs/lbslocdatasourcegpsbase.h>

#include "LbsInternalInterface.h"

#include "lbsnetworkgatewayhandler.h"

#include "lbsautoclockadjust.h"

#include "lbsprocessuiddefs.h"

#include "utilfunctions.h"

#include <lbs/lbsextendedsatellite.h>

#include <lbs/lbsgpsmeasurement.h>

#include "lbsdevloggermacros.h"

#include <lbs/lbslocerrors.h>

#include <lbs/lbsgpsmeasurement.h>

#include "lbsqualityprofile.h"

#include <lbs/lbslocdatasourceclasstypes.h>

#include <lbs/epos_intgpshwstatus.h>

#include "lbscommoninternaldatatypes.h"

#include "lbsreffnpint.h"

#include "lbsnetregstatusint.h"

#ifdef AGPS_MODULE_TESTING

#include "lbslocsourcegps.h"

#endif

#ifdef AGPS_MANAGER_TESTING

#include "ctestgpsmodule.h"

#endif

class RLbsPositionUpdates;

const TInt64 KTrackingOffTimeout = 30000000;//30s

const RLbsPositionUpdateRequests::TChannelIdentifer KChannelIdentifierLS = 

	{

		{KLbsGpsLocManagerUidValue},{KLbsLocServerUidValue}

	};

const RLbsPositionUpdateRequests::TChannelIdentifer KChannelIdentifierNRH = 

	{

		{KLbsGpsLocManagerUidValue},{KLbsNetRequestHandlerUidValue}

	};

#include "LbsAssistanceDataLogEvent.h"

const TInt KLbsLogQueueSize = 10;

// Definitions of constants to represent positioning methods (definitions are local

// to this file, not LBS-wide)

static const TPositionModuleInfo::TTechnologyType KLbsMethodNone =

												TPositionModuleInfo::ETechnologyUnknown;

static const TPositionModuleInfo::TTechnologyType KLbsMethodAutonomous =

												TPositionModuleInfo::ETechnologyTerminal;

static const TPositionModuleInfo::TTechnologyType KLbsMethodTerminalBased =

											 	TPositionModuleInfo::ETechnologyTerminal |

									 	    	TPositionModuleInfo::ETechnologyAssisted;

static const TPositionModuleInfo::TTechnologyType KLbsMethodTerminalAssisted = 

												TPositionModuleInfo::ETechnologyNetwork |

										        TPositionModuleInfo::ETechnologyAssisted;

static const TPositionModuleInfo::TTechnologyType KLbsMethodDual = 

											    TPositionModuleInfo::ETechnologyNetwork |

												TPositionModuleInfo::ETechnologyTerminal |

												TPositionModuleInfo::ETechnologyAssisted;

// Gps Options Combination Table entry

struct TLbsGpsCombinedModeTableEntry

	{

	TPositionModuleInfo::TTechnologyType iLSPreferredMode;

	TPositionModuleInfo::TTechnologyType iLSAlternativeMode;

	TPositionModuleInfo::TTechnologyType iNRHPreferredMode;

	TPositionModuleInfo::TTechnologyType iNRHAlternativeMode;

	TPositionModuleInfo::TTechnologyType iResultingMode;

	};

// Module supports Autonomous only.

static const TLbsGpsCombinedModeTableEntry KLbsAutonomousTable[] = 

{

//LS Preferred				//LS Altenative		//NRH Preferred				//NRH Alternative		// Result

{KLbsMethodAutonomous, 		KLbsMethodNone, 	KLbsMethodAutonomous,		KLbsMethodNone,		KLbsMethodAutonomous}

};

static const TInt KLbsAutonomousTableCount(sizeof(KLbsAutonomousTable) / sizeof(TLbsGpsCombinedModeTableEntry));

// Module supports Terminal-Based only.

static const TLbsGpsCombinedModeTableEntry KLbsTBTable[] = 

{

//LS Preferred				//LS Altenative		//NRH Preferred				//NRH Alternative		// Result

{KLbsMethodAutonomous, 		KLbsMethodNone, 	KLbsMethodAutonomous,		KLbsMethodNone,		KLbsMethodAutonomous},

{KLbsMethodAutonomous,		KLbsMethodNone,		KLbsMethodTerminalBased,	KLbsMethodNone,	    KLbsMethodTerminalBased},

{KLbsMethodTerminalBased, 	KLbsMethodNone, 	KLbsMethodAutonomous, 		KLbsMethodNone,		KLbsMethodTerminalBased},

{KLbsMethodTerminalBased, 	KLbsMethodNone, 	KLbsMethodTerminalBased, 	KLbsMethodNone,		KLbsMethodTerminalBased},

};

static const TInt KLbsTBTableCount(sizeof(KLbsTBTable) / sizeof(TLbsGpsCombinedModeTableEntry));

// Module supports Terminal-Assisted only.

static const TLbsGpsCombinedModeTableEntry KLbsTATable[] = 

{

//LS Preferred				//LS Altenative		//NRH Preferred					// NRH Alternative	// Result

{KLbsMethodTerminalAssisted, KLbsMethodNone, 	KLbsMethodTerminalAssisted,		KLbsMethodNone,		KLbsMethodTerminalAssisted},

};

static const TInt KLbsTATableCount(sizeof(KLbsTATable) / sizeof(TLbsGpsCombinedModeTableEntry));

// Module supports either Terminal-Assisted or Terminal-Based (but not both at the same time).

static const TLbsGpsCombinedModeTableEntry KLbsTBOrTATable[] = 

{

//LS Preferred					//LS Altenative		//NRH Preferred				//NRH Alternative		// Result

{KLbsMethodAutonomous, 	    	KLbsMethodNone, 	KLbsMethodAutonomous,		KLbsMethodNone,		KLbsMethodAutonomous},

{KLbsMethodAutonomous,			KLbsMethodNone,		KLbsMethodTerminalBased,	KLbsMethodNone,	    KLbsMethodTerminalBased},

{KLbsMethodAutonomous,			KLbsMethodNone,		KLbsMethodTerminalAssisted,	KLbsMethodNone,	    KLbsMethodTerminalAssisted},

{KLbsMethodTerminalBased, 		KLbsMethodNone, 	KLbsMethodAutonomous, 		KLbsMethodNone,		KLbsMethodTerminalBased},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 	KLbsMethodTerminalBased, 	KLbsMethodNone,		KLbsMethodTerminalBased},

{KLbsMethodTerminalBased, 		KLbsMethodNone, 	KLbsMethodTerminalAssisted, KLbsMethodNone,		KLbsMethodTerminalAssisted},

{KLbsMethodTerminalAssisted,	KLbsMethodNone, 	KLbsMethodAutonomous, 		KLbsMethodNone,		KLbsMethodAutonomous},

{KLbsMethodTerminalAssisted,	KLbsMethodNone,		KLbsMethodTerminalBased,	KLbsMethodNone,	    KLbsMethodTerminalBased},

{KLbsMethodTerminalAssisted,	KLbsMethodNone, 	KLbsMethodTerminalAssisted, KLbsMethodNone,		KLbsMethodTerminalAssisted},

};

static const TInt KLbsTBOrTATableCount(sizeof(KLbsTBOrTATable) / sizeof(TLbsGpsCombinedModeTableEntry));

// Module supports Terminal-Assisted and Terminal-Base simultaneously.

static const TLbsGpsCombinedModeTableEntry KLbsTBAndTATable[] = 

{

//LS Preferred					//LS Altenative			//NRH Preferred				//NRH Alternative			// Result

{KLbsMethodAutonomous, 	    	KLbsMethodNone, 		KLbsMethodAutonomous,		KLbsMethodNone,				KLbsMethodAutonomous},

{KLbsMethodAutonomous,			KLbsMethodNone,			KLbsMethodTerminalBased,	KLbsMethodNone,	    		KLbsMethodTerminalBased},

{KLbsMethodAutonomous, 	    	KLbsMethodNone, 		KLbsMethodTerminalAssisted,	KLbsMethodNone,				KLbsMethodDual},

{KLbsMethodAutonomous,			KLbsMethodNone,			KLbsMethodTerminalAssisted,	KLbsMethodAutonomous,		KLbsMethodDual},

{KLbsMethodAutonomous,			KLbsMethodNone,			KLbsMethodAutonomous,		KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodAutonomous, 	    	KLbsMethodNone, 		KLbsMethodTerminalBased,	KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodAutonomous, 	    	KLbsMethodNone, 		KLbsMethodTerminalAssisted,	KLbsMethodTerminalBased,	KLbsMethodDual},

{KLbsMethodTerminalBased, 		KLbsMethodNone, 		KLbsMethodAutonomous, 		KLbsMethodNone,				KLbsMethodTerminalBased},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 		KLbsMethodTerminalBased, 	KLbsMethodNone,				KLbsMethodTerminalBased},

{KLbsMethodTerminalBased, 		KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodNone,				KLbsMethodDual},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodAutonomous,		KLbsMethodDual},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 		KLbsMethodAutonomous,		KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 		KLbsMethodTerminalBased, 	KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodTerminalBased,   	KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodTerminalBased	,	KLbsMethodDual},

{KLbsMethodTerminalAssisted, 	KLbsMethodNone, 		KLbsMethodAutonomous, 		KLbsMethodNone,				KLbsMethodDual},

{KLbsMethodTerminalAssisted,   	KLbsMethodNone, 		KLbsMethodTerminalBased, 	KLbsMethodNone,				KLbsMethodDual},

{KLbsMethodTerminalAssisted, 	KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodNone,				KLbsMethodTerminalAssisted},

{KLbsMethodTerminalAssisted,   	KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodAutonomous,		KLbsMethodDual},

{KLbsMethodTerminalAssisted,   	KLbsMethodNone, 		KLbsMethodAutonomous, 		KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodTerminalAssisted,   	KLbsMethodNone, 		KLbsMethodTerminalBased, 	KLbsMethodTerminalAssisted,	KLbsMethodDual},

{KLbsMethodTerminalAssisted,   	KLbsMethodNone, 		KLbsMethodTerminalAssisted, KLbsMethodTerminalBased,	KLbsMethodDual},

};

static const TInt KLbsTBAndTATableCount(sizeof(KLbsTBAndTATable)/sizeof(TLbsGpsCombinedModeTableEntry));

//************************************************************************************************************

//	CManagerMainLogic

//************************************************************************************************************

#define __ASSERT_ALWAYSX(c,p) (void)((c)||(RDebug::Printf("Assert at line %d in file %s ",__LINE__,__FILE__),p,0));

CManagerMainLogic* CManagerMainLogic::NewL()

	{

	LBSLOG(ELogP1, "CManagerMainLogic::NewL() Begin\n");

	CManagerMainLogic* self = new(ELeave) CManagerMainLogic;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	LBSLOG(ELogP1, "CManagerMainLogic::NewL() End\n");

	return self;

	}

//------------------------------------------------------------------------------------------------------------

CManagerMainLogic::CManagerMainLogic() :

	iClosingDown(EFalse),

	iLSReqState(EReqNone),

	iSessionId(KLbsGpsLocManagerUid, 0),

	iLastTrackingFlagSentToNG(EFalse),

	iTrackingStateUnknown(ETrue),

	iPowerModeLS(CLbsLocationSourceGpsBase::EPowerModeUnknown),

	iPowerModeNRH(CLbsLocationSourceGpsBase::EPowerModeUnknown)

	{

	LBSLOG(ELogP1, "CManagerMainLogic::CManagerMainLogic()\n");

	}

//------------------------------------------------------------------------------------------------------------

void CManagerMainLogic::ConstructL()

	{

	LBSLOG(ELogP1, "CManagerMainLogic::ConstructL() Begin\n");

	iQuietus = CQuietus::NewL();

    // Create the monitor which detects a closedown signal from

    // the LBS Root Process.

    iCloseDownRequestDetector = CLbsCloseDownRequestDetector::NewL(this, KLbsGpsLocManagerUid);

    iPositionUpdates.OpenL(KLbsGpsLocManagerUid);

    iMeasurementUpdates.OpenL();

    iModuleStatus.OpenL(KLbsGpsLocManagerUid);

    iNetworkGatewayHandler = CNetworkGatewayHandler::NewL(this);

    iNRHLocationRequestHandler = CLocationRequestHandler::NewL(*this,KChannelIdentifierNRH);

    iLocSvrLocationRequestHandler = CLocationRequestHandler::NewL(*this,KChannelIdentifierLS);

    iEarlyCompletionUpdateHandler = CEarlyCompletionUpdateHandler::NewL(this);

    iEarlyCompletionUpdateHandler->ListenForEarlyCompletionUpdates();

    TPositionModuleStatus moduleStatus;

    // set initial dynamic module status and tell interested parties

    moduleStatus.SetDeviceStatus(TPositionModuleStatus::EDeviceInactive);

    moduleStatus.SetDataQualityStatus(TPositionModuleStatus::EDataQualityUnknown);

    TPositionModuleStatusEventBase::TModuleEvent occurredEventsSinceLastSet = 

                    TPositionModuleStatusEventBase::EEventDeviceStatus | TPositionModuleStatusEventBase::EEventDataQualityStatus;

    iModuleStatus.SetModuleStatus(&moduleStatus,sizeof(moduleStatus),occurredEventsSinceLastSet);

    LBSLOG(ELogP9, "->S CLbsLocationSourceGpsBase::NewL() AGPSModule\n");

    LBSLOG2(ELogP9, "  > CManagerMainLogic this  = 0x%08X\n", this);

	iPosIntGpsHwStatus = CPosIntGpsHwStatus::NewL();

#ifdef 	AGPS_MODULE_TESTING

    // ECOM plug-in not used in unit test

    iLocationSource = CLbsLocationSourceGps::NewL(*this);

    // When module testing there is no root process so the device capabilities

    // are not available from LbsModuleInfo

    iCapabilities = TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB;

#elif defined(AGPS_MANAGER_TESTING)

    // ECOM plug-in not used in unit test

    iLocationSource = CTestGpsModule::NewL(*this);

    // When unit-testing there is no root process so the device capabilities

    // are not available from LbsModuleInfo...read capabilities from the 

    // corresponding test property

    TInt capabilities = 0;

    TUid KSuiteExeUid = {0x102869CB};

    TUint KGpsModeCapabilities = 0;

    TInt err = RProperty::Get(KSuiteExeUid, KGpsModeCapabilities, capabilities);

    ASSERT(err == KErrNone);

    iCapabilities = capabilities;		

#else

    // Instantiate Ecom plugin

    TUid dataSourceId;

    TInt result = LbsModuleInfo::GetDataSourceId(KLbsGpsLocManagerUid, dataSourceId);

    LBSLOG2(ELogP9, "  > TUid dataSourceId  = 0x%08X\n", dataSourceId.iUid);

    iLocationSource = CLbsLocationSourceGpsBase::NewL(*this, dataSourceId);

    // Get capabilities from  module info

    User::LeaveIfError(LbsModuleInfo::GetDeviceCapabilities(KLbsGpsLocManagerUid, iCapabilities));

#endif

    iAutoClockAdjust = CAutoClockAdjust::NewL();

    // Used to send Tracking Off if the Loc Server doesn't keep sending location requests.

    iTimer = CLbsCallbackTimer::NewL(*this);

    // Disable tracking if no messages received from the Loc Server before timeout

    RestartTimerIfTracking();

    // Open logger

    iLogger.Open(KLbsLogQueueSize);

    iSessionClosureData.iNotify = EFalse;		

    // Read the admin setting for the lag timer

    iAdmin = CLbsAdmin::NewL();

    GetFinalNetPositionLagFromAdminProfileL();

    iNetRegStatus.OpenL();

		#if defined(_DEBUG)

			// For OOM testing. The listener will force an error on the next heap 

			// allocation when it is kicked by test code.

			iOomListener = CLbsOomListener::NewL();

			iOomListener->StartGettingRequests();

		#endif  

	LBSLOG(ELogP1, "CManagerMainLogic::ConstructL() End\n");

	}

//------------------------------------------------------------------------------------------------------------

CManagerMainLogic::~CManagerMainLogic()

	{

	LBSLOG(ELogP1, "CManagerMainLogic::~CManagerMainLogic() Begin\n");

	LBSLOG(ELogP9, "->S CLbsLocationSourceGpsBase::~CLbsLocationSourceGpsBase() AGPSModule\n");

	delete iLocationSource;

#ifndef 	AGPS_MODULE_TESTING

	REComSession::FinalClose();

#endif

	delete iPosIntGpsHwStatus;

	delete iCloseDownRequestDetector;

	iLocationSource = NULL;

	delete iQuietus;

	iQuietus = NULL;

	iLocSvrLocationRequestHandler->Cancel();

	delete iLocSvrLocationRequestHandler;

	iLocSvrLocationRequestHandler = NULL;

	iEarlyCompletionUpdateHandler->Cancel();

	delete iEarlyCompletionUpdateHandler;

	iEarlyCompletionUpdateHandler = NULL;

	iNetworkGatewayHandler->Cancel();

	delete iNetworkGatewayHandler; 

	iNetworkGatewayHandler = NULL;

	iNRHLocationRequestHandler->Cancel();

	delete iNRHLocationRequestHandler;

	iNRHLocationRequestHandler = NULL;

	delete iAutoClockAdjust;

	iAutoClockAdjust = NULL;

	if (iTimer)	

		{

	iTimer->Cancel();

		}

	delete iTimer;

    delete iAdmin;

	// Close logger

	iLogger.Close();

    #if defined(_DEBUG)

		if(iOomListener)

			{

			iOomListener->Cancel();

			delete iOomListener;

			}

	#endif 

	LBSLOG(ELogP1, "CManagerMainLogic::~CManagerMainLogic() End\n");

	}

void CManagerMainLogic::GetFinalNetPositionLagFromAdminProfileL()

	{

	// Get the profile Id for self locate requests

	TLbsQualityProfileId profileId;

	TInt err = iAdmin->Get(KLbsSettingQualityProfileSelfLocate, profileId);

	if (err == KErrNone)

		{

		// Retrieve the quality profile that belongs to the given Id

		TQualityProfile quality;

		err = LbsQualityProfile::GetQualityProfileById(profileId, quality);

		if (err == KErrNone)

			{

			iFinalNetPositionLag = quality.FinalNetPositionLag();

			}

		else

			{

			iFinalNetPositionLag = 0;

			}

		}

	}

/*

 * Publish a dummy position on the position bus for the Loc Server, 

 * note that the NRH will ignore this update since the 'conflict control' flag (overloaded for this purpose) is set to TRUE 

 */

void CManagerMainLogic::PublishDummyPosition(TInt aReason)

	{

	TPositionExtendedSatelliteInfo dummySatInfo;

	TTime dummyTime = 0;

	iPositionUpdates.SetPositionInfo(aReason, ETrue, &dummySatInfo, sizeof(TPositionExtendedSatelliteInfo), dummyTime, dummyTime);

	}

/*

 * Publish a dummy Assistance Data Event with the given error, for the integration module.

 * Note: we use 0xFFFFFFFF when informing the module of an error

 */

void CManagerMainLogic::PublishDummyAssistDataEvent(TInt aError)

	{

	iLocationSource->AssistanceDataEvent(aError, KLbsDummyAssistanceDataMaskWithError);

	}

//-----------------------------------------------------------------------------

TVersion CManagerMainLogic::Version()

	{

	LBSLOG(ELogP1, "CManagerMainLogic::Version()\n");

	LBSLOG(ELogP9, "<-S MLbsLocationSourceGpsObserver::Version() AGPSModule\n");

	LBSLOG(ELogP9, "  Return TVersion  = 1, 0, 0\n");

	return TVersion(1,0,0);

	}

//-----------------------------------------------------------------------------

// New location arrives from integration module ...

// from MLbsLocationSourceGpsObserver

//

void CManagerMainLogic::UpdateLocation

	(

	TInt aStatus,

	const TPositionInfoBase* aPosInfoArray[],

	TInt aNumItems,

	const TTime& aTargetTime

	)

	{

	LBSLOG(ELogP1, "CManagerMainLogic::UpdateLocation() Begin\n");

	LBSLOG(ELogP9, "<-A MLbsLocationSourceGpsObserver::UpdateLocation() AGPSModule\n");

	LBSLOG2(ELogP9, "  > TInt aStatus  = %d\n", aStatus);

	LBSLOG2(ELogP9, "  > TInt aNumItems  = %d\n", aNumItems);

	LBSLOG5(ELogP9, "  > TTime TargetTime  = %02d:%02d:%02d.%06d\n", aTargetTime.DateTime().Hour(), 

																aTargetTime.DateTime().Minute(),

																aTargetTime.DateTime().Second(),

																aTargetTime.DateTime().MicroSecond());

	LBS_RDEBUG_ARGINT("AGPSMod", "LBS", "UpdateLocation", aStatus);

#ifdef ENABLE_LBS_DEV_LOGGER

	//Loop through the PositionInfoArray

	if(aPosInfoArray != NULL)

		{

		for(TInt posNum=0; posNum<aNumItems; posNum++)

			{

			const TPositionInfoBase& positionPtrTemp = (reinterpret_cast<const TPositionInfoBase&>(*(aPosInfoArray[posNum])));

			LBSLOG2(ELogP9, "  > TPositionInfoBase aPosInfoArray[%d]  =\n", posNum);

			LBSLOG_TPOSITIONINFOBASE(positionPtrTemp);

			(void) positionPtrTemp; // avoid a compiler warning

			}

		}

#endif

	(void)aNumItems;

	__ASSERT_ALWAYSX(aPosInfoArray != NULL,User::Panic(KLbsAGPSManFault, KErrArgument));

    TInt positionCalculationIndex; // index where the position calculation is in the array

    TInt measurementIndex; // index where the satellite measurement is in the array

    TBool positionCalculationPossible = EFalse;

	TTime timeNow;

	timeNow.UniversalTime(); //done here so that position and measurement are published with same time.

	// If the update contains an error then this error will be passed on the location bus, 

    // and if it's the case it will be sent with the measurements as well

    if(aStatus < 0)

    	{

    	LBSLOG(ELogP1,"There was an error returned");

		GetGpsUpdateIndexes(aPosInfoArray, aNumItems, positionCalculationIndex, measurementIndex);

    	if(measurementIndex >= 0)

    		{

    		// There is some measurement information so publish it together with the error

			const TPositionGpsMeasurementInfo* measurementPtr = (reinterpret_cast<const TPositionGpsMeasurementInfo*>(aPosInfoArray[measurementIndex]));

			iMeasurementUpdates.SetGpsMeasurementInfo(aStatus, measurementPtr, sizeof(TPositionGpsMeasurementInfo), timeNow);

			// Note: currently only doing this for any GPS mode except hybrid, so as not to adversely affect existing hybrid customers 

			// Since there's an error in the measurement, and if there is no position returned, publish it in a dummy position for the LS since he doesn't monitor measurement bus:

			if((positionCalculationIndex < 0) && (iCurrentPositioningMethod != KLbsMethodDual))

				{

				LBSLOG(ELogP1, "Publishing dummy position");

				PublishDummyPosition(aStatus);

				iLocSvrLocationRequestHandler->InvalidateRequest();

				iLSReqState = EReqNone;

				iNRHLocationRequestHandler->InvalidateRequest();

				RestartTimerIfTracking();				

				}

    		}

		if (positionCalculationIndex >= 0)

			{

			const TPositionModuleId id = {KLbsGpsLocManagerUidValue};

			TPosition pos;

			TUint attributes = 0; // only relevant when aStatus == KPositionCalculationFutile (>0).

			const TPositionExtendedSatelliteInfo* satPositionPtr = 

					(reinterpret_cast<const TPositionExtendedSatelliteInfo*>(aPosInfoArray[positionCalculationIndex]));

			TPositionExtendedSatelliteInfo position(*satPositionPtr);

			position.GetPosition(pos);

			LBSLOG3(ELogP2, "Lat=%3.4g. Long=%3.4g.\n", pos.Latitude(), pos.Longitude());

			position.SetModuleId(id);

			// Invalidate all the requests. No need to call CombineLocationRequests().	

			iLocSvrLocationRequestHandler->InvalidateRequest();

			iLSReqState = EReqNone;

			iNRHLocationRequestHandler->InvalidateRequest();

			// If the network did not request ETechnologyTerminal then it doesn't need to know about

			// position updates. Set the 'conflict flag' to make the NRH ignore the position update.

			//

			TBool nrhToIgnoreUpdate = EFalse;

			if (iNRHLocationRequestHandler->IsRequestActive() && 

				!(GetTechnologyTypeFromNrhRequest(0) & TPositionModuleInfo::ETechnologyTerminal) &&

				!(GetTechnologyTypeFromNrhRequest(1) & TPositionModuleInfo::ETechnologyTerminal))

				{

				nrhToIgnoreUpdate = ETrue;

				}

			// The position update is about to be published for the Location Server...

			// ...here we take the opportunity to let the LS know if we are collecting