// Copyright (c) 2008-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

 @internalTechnology

 @released

*/

#include "lbsdevloggermacros.h"

#include "agpsinterfacehandler.h"

#include "nrhpanic.h"

#include "lbsnetregstatusint.h"

// Pre-defined technology types for common positioning modes.

const TPositionModuleInfo::TTechnologyType KTerminalAssistedMode = 

		(TPositionModuleInfo::ETechnologyNetwork |

		 TPositionModuleInfo::ETechnologyAssisted);

const TPositionModuleInfo::TTechnologyType KTerminalBasedMode = 

		(TPositionModuleInfo::ETechnologyTerminal |

		 TPositionModuleInfo::ETechnologyAssisted);

const TPositionModuleInfo::TTechnologyType KAutonomousMode = 

		(TPositionModuleInfo::ETechnologyTerminal);

/** Constructor.

*/

CAgpsInterfaceHandler::CAgpsInterfaceHandler(

		MAgpsInterfaceHandlerObserver& aObserver,

		CLbsAdmin& aAdmin,

		RLbsNetworkRegistrationStatus& aNetRegStatus) :

	iObserver(aObserver),

	iAdmin(aAdmin),

	iNetRegStatus(aNetRegStatus),

	iX3pStatus(EX3pStatusIdle),

	iCombinedPowerModeAdvice(TLbsPositionUpdateRequestBase::EPowerAdviceOff),

	iCombinedRequestGpsMode(EGpsRequestModeUnknown)

	{

	}

/** Destructor.

*/

CAgpsInterfaceHandler::~CAgpsInterfaceHandler()

	{

	iRequests.Close();

	delete iMeasurementUpdateMonitor;

	delete iLocationUpdateMonitor;

	}

/**

*/

CAgpsInterfaceHandler* CAgpsInterfaceHandler::NewL(

		MAgpsInterfaceHandlerObserver& aObserver,

		CLbsAdmin& aAdmin,

		RLbsNetworkRegistrationStatus& aNetRegStatus)

	{

	CAgpsInterfaceHandler* self = new (ELeave) CAgpsInterfaceHandler(aObserver, aAdmin, aNetRegStatus);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

*/

const TInt KLbsDefaultMaxNumLocationRequests   = 4;

void CAgpsInterfaceHandler::ConstructL()

	{

	iLocationUpdateMonitor = CLbsLocUpdateMonitor::NewL(*this);

	iMeasurementUpdateMonitor = CLbsMeasurementInfoMonitor::NewL(*this);

	TInt err = iAdmin.Get(KLbsSettingMaximumExternalLocateRequests, iMaxNumLocationRequests);

	if (err != KErrNone)

		{

		iMaxNumLocationRequests = KLbsDefaultMaxNumLocationRequests;

		}

	iRequests.ReserveL(iMaxNumLocationRequests+1); // +1 for processing emergencies

	// Get the A-GPS device mode capabilities:

	err = LbsModuleInfo::GetDeviceCapabilities(KLbsGpsLocManagerUid, iDeviceGpsModeCaps);

	if(err != KErrNone || (iDeviceGpsModeCaps==TPositionModuleInfoExtended::EDeviceGpsModeNone))

		{

		// Assume module supports hybrid if it has not reported its capabilities in module info file

		iDeviceGpsModeCaps = TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB;

		}

	}

/** Called to initialise a location request.

This is used to tell the AGPS Interface that a GPS location request

is goind to happen 'soon'. Usually, this means we should update the

power mode advice to at least 'standby', to give the GPS hardware

as much time as possible to warm up.

@param aSessionId Session Id of the request that is started.

@return KErrNone if no problems, or one of the standard Symbian

		error codes if there was a problem storing the new request.

*/

TInt CAgpsInterfaceHandler::PreStartPositioning(

		const TLbsNetSessionIdInt& aSessionId, TBool aEmergency)

	{

	// Add the request to the array

	TAgpsRequest newRequest;

	newRequest.iSessionId = &aSessionId;

	newRequest.iState = EAgpsRequestStateIdle;

	TInt err = AddOrUpdateRequest(newRequest, aEmergency);

	if (err != KErrNone)

		{

		return err;

		}

	// Update the GPS power mode advice to the AGPS Manager

	TLbsPositionUpdateRequestBase::TPowerAdvice newPowerAdvice;

	CalculateCombinedPowerModeAdvice(newPowerAdvice);

	if (newPowerAdvice != iCombinedPowerModeAdvice)

		{

		iCombinedPowerModeAdvice = newPowerAdvice;

		iLocationUpdateMonitor->SendPowerAdviceRequest(iCombinedPowerModeAdvice);

		}

	return err;

	}

/** Called to start a location request.

This is used when the CLbsPrivLocFsm actually wants to send

a location request to the AGPS Manager.

This function must combine the new request with any existing

request(s) - this includes quality params and GPS mode, before

sending a request to the AGPS Manager.

@param aSessionId Session Id of the request that is started.

@param aMethod GPS mode(s) to use, as set by the network.

@param aQuality quality params to use, as set by the network.

@return KErrNone if no problems, or one of the standard Symbian

		error codes if there was a problem storing the new request.

*/

TInt CAgpsInterfaceHandler::StartPositioning(

		const TLbsNetSessionIdInt& aSessionId,

		const TLbsNetPosRequestMethodInt& aMethod,

		const TLbsNetPosRequestQualityInt& aQuality,

		TBool aEmergency)

	{

	// Check that the new request GPS mode is valid

	TGpsRequestMode newRequestGpsMode = ConvertPosMethodToGpsRequestMode(aMethod);

	TGpsRequestMode newCombinedGpsMode;

	TInt err = CalculateNewCombinedRequestMethod(

								iCombinedRequestGpsMode,

								newRequestGpsMode,

								newCombinedGpsMode,

								aEmergency);

	if (err != KErrNone)

		{

		RemoveRequest(aSessionId);

		return err;

		}

	// Add (or update) the request to the buffer

	TAgpsRequest newRequest;

	newRequest.iSessionId = &aSessionId;

	newRequest.iState = EAgpsRequestStateActive;

	newRequest.iGpsMode = newRequestGpsMode;

	newRequest.iPosQuality = &aQuality;

	TTime now;

	now.UniversalTime();

	newRequest.iEndTime = (now + aQuality.MaxFixTime());

	newRequest.iGpsTimingOfCellFramesRequested = aMethod.GpsTimingOfCellFramesRequested();

	err = AddOrUpdateRequest(newRequest, aEmergency);

	if (err != KErrNone)

		{

		return err;

		}

	// Use the new combined GPS mode

	iCombinedRequestGpsMode = newCombinedGpsMode;

	// Combine Quality.

	CalculateCombinedRequestQuality();

	// Send the new combined request to the AGPS manager.

	SendCombinedLocationRequest();

	return err;

	}

/** Temporarily stop an existing location request.

This function is used when a location request has finished,

but the session it belongs to hasn't finished yet. For example,

in terminal assisted or hybrid mode, there is more than one location

request within a session, so the it should not be removed from the

list until it has completely finished.

*/

void CAgpsInterfaceHandler::HoldPositioning(

		const TLbsNetSessionIdInt& aSessionId, 

		TInt /*aReason*/)

	{

	// Find a matching request.

	TInt index = iRequests.Find(aSessionId, IsSessionIdEqual);

	if (index == KErrNotFound)

		{

		// If can't find one, just ignore it (but LBSLOG_ERR)?

		LBSLOG_ERR2(ELogP3, "Failed to find a match for sessionId %d.", aSessionId.SessionNum());

		return;

		}

	// Set the request to 'hold'.

	iRequests[index].iState = EAgpsRequestStateHold;

	}

/** Stop and remove a location request.

This function is used when a session has finished, and

the location request can be removed from the list.

*/

void CAgpsInterfaceHandler::StopPositioning(

		const TLbsNetSessionIdInt& aSessionId)

	{	

	// Remove request from iRequests.

	RemoveRequest(aSessionId);

	if (IsAnyRequestState(EAgpsRequestStateActive))

		{

		// If there are any other active requests, combine them and send

		// a new location request.

		// Combine quality

		CalculateCombinedRequestQuality();

		// Send the new combined request to the AGPS manager.

		SendCombinedLocationRequest();

		}

	else if (!IsAnyRequestState(EAgpsRequestStateHold)

			 && iLocationRequestActive)

		{

		// There are no requests that are either active or on hold, so send 

		// a cancel message to the AGPS manager.

		CalculateCombinedPowerModeAdvice(iCombinedPowerModeAdvice);

		iLocationUpdateMonitor->SendCancelRequest(iCombinedPowerModeAdvice);

		iLocationRequestActive = EFalse;

		// Also reset the combined request parameters

		iCombinedRequestGpsMode = EGpsRequestModeUnknown;

		}

	else

		{

		// Update the GPS power mode advice to the AGPS Manager

		TLbsPositionUpdateRequestBase::TPowerAdvice newPowerAdvice;

		CalculateCombinedPowerModeAdvice(newPowerAdvice);

		if (newPowerAdvice != iCombinedPowerModeAdvice)

			{

			iCombinedPowerModeAdvice = newPowerAdvice;

			iLocationUpdateMonitor->SendPowerAdviceRequest(iCombinedPowerModeAdvice);

			}		

		}

	}

/** Check that it is ok to send the position update to state machine(s).

Some position updates should be ignored by the NRH, these are:

1) Conflict control updates (aConflictControl = ETrue), only the 

   LocServer is interested in these.

2) In hybrid, if the params are 'invalid'. Some licensees use special

   values in the position update to flag that it should not be used,

   e.g. if the horizontal accuracy is 0.

*/

TBool CAgpsInterfaceHandler::CheckPositionUpdateIsValid(

		TBool aConflictControl,

		TInt aReason,

		const TPositionExtendedSatelliteInfo& aPosInfo,

		const TTime& /*aActualTime*/)

	{

	// Some updates are only meant for the LocServer - they

	// have aConflictControl == ETrue. We shouldn't send these

	// to the PrivLocHandler.

	if (aConflictControl)

		{

		return EFalse;

		}

	// For hybrid position, first check whether the data is valid. If any of 

	// longitude, latitude, or horizontal accuracy is missing, or horizontal 

	// accuracy is zero, then it's not valid, so there's no point going any 

	// further.

	if ((iCombinedRequestGpsMode == EGpsRequestModeHybrid) && (aReason == KErrNone))

		{

		TPosition pos;

		aPosInfo.GetPosition(pos);

		if (Math::IsNaN(pos.Latitude()) || 

			Math::IsNaN(pos.Longitude()) || 

			Math::IsNaN(pos.HorizontalAccuracy()) || 

			(pos.HorizontalAccuracy() == 0))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

/** Get the latest update value from the GPS position bus.

Note: Some updates are intended only for the LocServer, these

all have conflictControl == ETrue, so in this case we return 

KErrNotFound to tell the caller it shouldn't be used.

@param aReason Reason code for the update. Set by the AGPS manager.

@param aPosInfo Position data for the update.

@param aTimeStamp Time the update arrived in the LBS system.

@return KErrNone usually, but KErrNotFound if the update is invalid.

*/

TInt CAgpsInterfaceHandler::GetPosition(

		TInt& aReason,

		TPositionExtendedSatelliteInfo& aPosInfo,

		TTime& aTimeStamp)

	{

	TBool conflictControl;

	iLocationUpdateMonitor->GetPosition(

			conflictControl,

			aReason,

			aPosInfo,

			aTimeStamp);

	if (CheckPositionUpdateIsValid(conflictControl,

								   aReason,

								   aPosInfo,

								   aTimeStamp))

		{

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

/** Get the latest update from the GPS measurement results bus.

*/

void CAgpsInterfaceHandler::GetMeasurement(

		TInt& aReason,

		TPositionGpsMeasurementInfo& aPosInfo,

		TTime& aTimeStamp)

	{

	iMeasurementUpdateMonitor->GetMeasurement(aReason, aPosInfo, aTimeStamp);

	}

/** Callback for when a GPS update is sent by the AGPS manager.

*/

void CAgpsInterfaceHandler::OnPositionUpdate(

			TBool aConflictControl,

			TInt aReason,

			const TPositionExtendedSatelliteInfo& aPosInfo,

			const TTime& aActualTime)

	{	

	LBSLOG(ELogP1, "CAgpsInterfaceHandler::OnPositionUpdate");

	if (CheckPositionUpdateIsValid(aConflictControl,

								   aReason,

								   aPosInfo,

								   aActualTime))

		{

		// Send the update to the PrivLocHandler

		iObserver.OnAgpsPositionUpdate(aReason, aPosInfo, aActualTime);

		}

	}

/** Callback for when a GPS Measured Results update is sent by the AGPS manager.

*/

void CAgpsInterfaceHandler::OnMeasurementInfoUpdate(

			TInt aReason, 

			const TPositionGpsMeasurementInfo& aMeasurementResults,

			const TTime& aActualTime)

	{

	// Send result to observer

	iObserver.OnAgpsMeasurementUpdate(aReason, aMeasurementResults, aActualTime);

	}

/** Combines the quality parameters of all the active requests.

Note: Only requests which are 'active' should be considered when

combining the quality params.

*/

void CAgpsInterfaceHandler::CalculateCombinedRequestQuality()

	{

	// Set the initial values to start from

	TReal32 minHorizAcc(10000000000000000.0);

	TReal32 minVertAcc(10000000000000000.0);

	TTimeIntervalMicroSeconds maxMaxFixTime(0);

	TTime now;

	now.UniversalTime();

	// Combine each request in turn but only if it is 'active'.

	const TInt count = iRequests.Count();

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

		{

		if (iRequests[i].iState == EAgpsRequestStateActive)

			{

			// Horizontal accuracy = strictest accuracy.

			minHorizAcc = Min(minHorizAcc,

							  iRequests[i].iPosQuality->MinHorizontalAccuracy());

			// Vertical accuracy = strictest accuracy.

			minVertAcc = Min(minVertAcc,

							 iRequests[i].iPosQuality->MinVerticalAccuracy());

			// Max fix time = greatest/longest time.

			TTimeIntervalMicroSeconds maxFixTime = (iRequests[i].iEndTime.Int64() - now.Int64());

			maxMaxFixTime = Max(maxMaxFixTime, maxFixTime);

			}

		}

	// Set the combined accuracy

	iCombinedRequestQuality.SetMinHorizontalAccuracy(minHorizAcc);

	iCombinedRequestQuality.SetMinVerticalAccuracy(minVertAcc);

	iCombinedRequestQuality.SetMaxFixTime(maxMaxFixTime);

	}

/** Calculates the power mode advice to send to the AGPS manager.

Use the state of the X3P handler and the combined state of the current

requests to calculate the power mode advice to send to the AGPS

manager.

*/

void CAgpsInterfaceHandler::CalculateCombinedPowerModeAdvice(

		TLbsPositionUpdateRequestBase::TPowerAdvice& aCombinedPowerAdvice)

	{

	// Calculate combined state for all requests

	TAgpsRequestState combinedState(EAgpsRequestStateUnknown);

	if (IsAnyRequestState(EAgpsRequestStateActive))

		{

		combinedState = EAgpsRequestStateActive;

		}

	else if (IsAnyRequestState(EAgpsRequestStateHold))

		{

		combinedState = EAgpsRequestStateHold;

		}

	else if (IsAnyRequestState(EAgpsRequestStateIdle))

		{

		combinedState = EAgpsRequestStateIdle;

		}

	// Select the power advice to send to the AGPS manager by using

	// a look-up table.

	//

	// The look-up table below is described in the NRH design document,

	// so if it is changed, the design doc should also be updated to 

	// keep it in sync.

	const TInt KNumX3pStates = 3;

	const TInt KNumLocRequestStates = 4;

	static const TLbsPositionUpdateRequestBase::TPowerAdvice KPowerAdviceTable[KNumX3pStates][KNumLocRequestStates] = 

		{

			{ TLbsPositionUpdateRequestBase::EPowerAdviceOff, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn },

			{ TLbsPositionUpdateRequestBase::EPowerAdviceStandby, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn },

			{ TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn, 

			  TLbsPositionUpdateRequestBase::EPowerAdviceOn }

		};

	// Note: Because this table uses the enum values directly as indices,

	//       if either enum changes, you need to re-do the table above as well.

	__ASSERT_ALWAYS(iX3pStatus < KNumX3pStates, Panic(ENrhPanicInvalidPowerModeAdviceIndex));

	aCombinedPowerAdvice = KPowerAdviceTable[iX3pStatus][combinedState];

	}

/**

 Goes through all requests and decides if the timing of cell frames is requested or not

 @return ETrue if the timing of cell frames is requested

 */

TBool CAgpsInterfaceHandler::CalculateCombinedTimingOfCellFramesRequested()

	{

	TBool timingOfCellFramesRequested(EFalse);

	// Combine each request in turn but only if it is 'active'.

	const TInt count = iRequests.Count();

	// Make the flag to be ETrue if there are any requests active or on hold that have the flag

	// set to ETrue

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

		{

		if((iRequests[i].iState == EAgpsRequestStateActive || 

				iRequests[i].iState == EAgpsRequestStateHold) && 

			iRequests[i].iGpsTimingOfCellFramesRequested)

			{

			timingOfCellFramesRequested = ETrue;

			break;

			}

		}

	return timingOfCellFramesRequested;

	}

/** Performs the common actions for sending a location request to the AGPS manager.

This function does common tasks such as calculating the power mode to send,

starting or stopping the needed monitors and actually sending the combined

request.

Note: Combining the quality params and/or GPS mode params is done differently