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

// This file provides the implementation of the class that manages

// assistance data during location requests.

// 

//

/**

 @file

 @internalTechnology

 @deprecated

*/

#include <e32base.h>

#include <lbs/lbsnetcommon.h>

#include <lbs/lbsnetprotocolbase.h>

#include <lbs/lbsassistancereferencelocation.h>

#include "suplassistancedatamgr.h"

#include "supldevloggermacros.h"

/** Constant to identify an empty set of assistance data.

*/

const TInt KAssistDataEmpty = 0;

/** KAssistDataReportTimer

Identity of timer

*/

const TInt KAssistDataReportTimer = 0x01;

/** KAssistDataReportTimerDurationInSec

Timer duration for when assistance data is expected from network

*/

const TInt KAssistDataReportTimerDurationInSec = 1;

/** Static constructor.

@return A new instance of the CSuplAssistanceDataManager class.

*/  

CSuplAssistanceDataManager* CSuplAssistanceDataManager::NewL(MSuplProtocolManagerObserver& aGateway)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::NewL() Begin\n");

	CSuplAssistanceDataManager* self = new (ELeave) CSuplAssistanceDataManager(aGateway);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::NewL() End\n");

	return self;

	}

/** Standard constructor.

*/  

CSuplAssistanceDataManager::CSuplAssistanceDataManager(MSuplProtocolManagerObserver& aGateway):

							iGateway(aGateway)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::CSuplAssistanceDataManager() Begin\n");

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::CSuplAssistanceDataManager() End\n");

	}

/** Standard destructor.

*/  

CSuplAssistanceDataManager::~CSuplAssistanceDataManager()

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::~CSuplAssistanceDataManager() Begin\n");

	delete iAssistDataReportTimer;

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::~CSuplAssistanceDataManager() End\n");

	}

/** Private second-stage constructor.

*/  

void CSuplAssistanceDataManager::ConstructL()

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::ConstructL() Begin\n");

	iAssistDataReportTimer = CLbsCallbackTimer::NewL(*this);

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::ConstructL() End\n");

	}

/** Process assistance data request.

This is called by the protocol manager to process an assistance data request

received from LBS.

The method first identifies any errors in the assistance data request mask. If any

assistance data types are unsupported, this method sends a response to LBS

for those types with error code KErrArgument.

Then, if there are any state machines ready to handle an assistance data request, the

iPendingDataMask mask is added to aDataRequestMask and then cleared. Otherwise, it is

aDataRequestMask that is added to iPendingDataMask.

The state machines that must receive the assitance data request are returned by this

method as a mask of type MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask.

@param aDataRequest The set of assistance data requested by LBS.

@return aDataRequest The set of assistance data that must be requested from the state machines

@return MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask the state machine that

		must receive the assistance data request.

*/

MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask CSuplAssistanceDataManager::ProcessDataRequest(TLbsAsistanceDataGroup& aDataRequestMask)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::ProcessDataRequest() Begin\n");

	// state machines ready for assistance data requests

	MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask readyMachinesMask = MLbsNetworkProtocolObserver::EServiceNone;

	// Identify invalid parts of the request.

	TLbsAsistanceDataGroup validSet = EAssistanceDataAquisitionAssistance

									 | EAssistanceDataBadSatList

									 | EAssistanceDataNavigationModel

									 | EAssistanceDataReferenceTime

									 | EAssistanceDataIonosphericModel

									 | EAssistanceDataReferenceLocation

									 | EAssistanceDataAlmanac

									 | EAssistanceDataPositioningGpsUtcModel;

	// Create a request error mask for any invalid parts of the request

	TLbsAsistanceDataGroup requestErrorMask = aDataRequestMask & ~validSet;

	if (requestErrorMask != 0)

		{

		// Send an error back to LBS for the assistance data types in the

		// error mask

		//

		RLbsAssistanceDataBuilderSet dummyAssistanceData; //ignored by LBS when error is not KErrNone

		iGateway.AssistanceDataInd(requestErrorMask, dummyAssistanceData, KErrArgument);

		}

	// Remove from the request mask any assistance data types reported to LBS

	// within the last second. Those need not be requested again. Remove also

	// invalid assitance data types

	aDataRequestMask = aDataRequestMask & ~iReportedDataMask & validSet;

	// See if there are any state machines ready to process assistance data requests

	// (they must get an assistance data request even if it is empty)

	if (iReadyMachinesMask != MLbsNetworkProtocolObserver::EServiceNone)

		{

		// Add pending assistance data to the request and clear the pending mask;

		aDataRequestMask = aDataRequestMask | iPendingDataMask;

		iPendingDataMask = KAssistDataEmpty;

		// The request will be forwarded to all the ready machines. After that

		// they are no longer ready for new assistance data requests (until they

		// reported as ready again with MachineReadyForAssistanceDataRequest())

		readyMachinesMask = iReadyMachinesMask;

		iReadyMachinesMask = MLbsNetworkProtocolObserver::EServiceNone;

		}

	else

		{

		// Add requested assistance data types to the pending ones

		iPendingDataMask = iPendingDataMask | aDataRequestMask;

		}

	// If any machine is going to get the assistance data request, remember what 

	// assistance data types are going to be retrieved by each state machine.

	if (readyMachinesMask != MLbsNetworkProtocolObserver::EServiceNone)

		{

		if (readyMachinesMask & MLbsNetworkProtocolObserver::EServiceSelfLocation)

			{

			iMoLrRequestedDataMask = aDataRequestMask;

			}

		if (readyMachinesMask & MLbsNetworkProtocolObserver::EServiceMobileTerminated)

			{

			iMtLrRequestedDataMask = aDataRequestMask;

			}

		}

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::ProcessDataRequest() End\n");

	return readyMachinesMask;

	}

/** Process Assistance Data Report

Called by the Protocol Manager when a state machine (aStateMachine) has reported that it

has obtained assistance data. The assistance data types reported in this call are those in

aDataReportMask. If the error code aReason is KErrNone, then the assistance data is be available

in aAssistanceDataBuilder.

The error in aReason applies to all of the assistance data types in aDataReportMask.

This method sends the Assistance Data (or error indication) to LBS.

If Reference Location is part of the reported set of assistance data, it is extracted,

converted to the format expected by LBS and sent to LBS.

@param aAssistanceData. The actual assistance data being reported when aReason is KErrNone

@param aDataReportMask. The assistanced data types being reported

@param aReason. If KErrNone, assistance data are being reported, otherwise, a failure to collect

				the assistance data types in aDataReportMask is what is being reported in this call.

@param aStateMachine. The service type of the state machine reporting the assistance data types.

					Used to identify the machine. @see MLbsNetworkProtocolObserver.

@param aSessionId. The unique ID of the session being conducted by the state machine that is reporting

					assistance data. Used when sendig reference location back to LBS.

*/

void CSuplAssistanceDataManager::AssistanceDataReport(const RLbsAssistanceDataBuilderSet& aAssistanceData,

						  const TLbsAsistanceDataGroup& aDataReportMask, TInt aReason,

						  const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aStateMachine,

						  const TLbsNetSessionId& aSessionId)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::AssistanceDataReport() Begin\n");

	TLbsAsistanceDataGroup missingDataTypes = KAssistDataEmpty;

	if (aReason != KErrNone)

		{

		// Errored assistance data should be reported to LBS.

		TLbsAsistanceDataGroup reportDataMask = KAssistDataEmpty;

		if (MLbsNetworkProtocolObserver::EServiceSelfLocation == aStateMachine)

			{

			// Report error on only those assistance data types that are not being

			// collected by any other state machines and have not been

			// reported recently

			reportDataMask = aDataReportMask & ~iMtLrRequestedDataMask & ~iReportedDataMask;

			iMoLrRequestedDataMask = KAssistDataEmpty;

			}

		else if (MLbsNetworkProtocolObserver::EServiceMobileTerminated == aStateMachine)

			{

			// Report error on only those assistance data types that are not being

			// collected by any other state machines and have not been

			// reported recently

			reportDataMask = aDataReportMask & ~iMoLrRequestedDataMask & ~iReportedDataMask;

			iMtLrRequestedDataMask = KAssistDataEmpty;

			}

		else

			{

			// This should not happen

			ASSERT(EFalse);

			}

		if (reportDataMask != KAssistDataEmpty)

			{

			iGateway.AssistanceDataInd(reportDataMask, aAssistanceData, KErrArgument);

			}

		}

	else

		{

		// Extract Reference Location from the reported assistance data if present and 

		// send it to LBS as a Location Update.

		//

		if (EAssistanceDataReferenceLocation == (aDataReportMask & EAssistanceDataReferenceLocation))

			{

			RReferenceLocationBuilder* refLocBuilderPtr;

			RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aAssistanceData);

			if (KErrNone == data.GetDataBuilder(refLocBuilderPtr))

				{

 				if (refLocBuilderPtr->IsDataAvailable())

					{

					// Create a Ref Loc Reader with data from the Builder

		            RReferenceLocationReader refLocReader;

					TInt err = KErrNone;

					TRAP(err,refLocReader.OpenL());

					if (KErrNone == err)

						{

						refLocReader.DataBuffer() = refLocBuilderPtr->DataBuffer();

						// Obtain position info from the Ref Loc Reader and set it in a TPositionInfo

						if(refLocReader.FieldExists(TReferenceLocation::EEllipsoidPointAltitudeEllipsoide))

							{

							REllipsoidPointAltitudeEllipsoideReader ellipsoidReader;

							refLocReader.GetFieldReader(TReferenceLocation::EEllipsoidPointAltitudeEllipsoide, ellipsoidReader);

							TPositionInfo positionInfo;

							TPosition position;

							TUint tempUint;

							TInt  tempInt;

							TReal64 latitudeDegrees;

							TReal64 longitudeDegrees;

							TReal32 altitudeMeters;

							TReal aux = 0;

							TReal32 uncertainty;

							position.SetCurrentTime();

							// Get latitude and convert to degrees

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::ELatitudeSign, tempInt);

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::ELatitude, tempUint);

							latitudeDegrees = (tempUint * 90.0) / 8388608.0; //*90/2^23 ; ETSI TS 123.032

	                        latitudeDegrees *= (tempInt == TEllipsoidPointAltitudeEllipsoide::ESouth)? -1: 1;

							// Get longitude and convert to degreees

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::ELongitude, tempInt);

							longitudeDegrees = (tempInt * 45.0) / 2097152.0; //*360/2^24; ETSI TS 123.032

							// Get altitude (meters) and apply sign

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::EAltitudeDirection, tempInt);

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::EAltitude, tempUint);

							altitudeMeters = tempUint; // ETSI TS 123.032

							altitudeMeters *= (tempInt == TEllipsoidPointAltitudeEllipsoide::EDepth)? -1: 1;

							position.SetCoordinate(latitudeDegrees, longitudeDegrees, altitudeMeters);

							// Get both horizontal uncertainties, convert to meters and set Horizontal Accuracy to the largest

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintySemiMajor, tempUint);

							Math::Pow(aux, 1.1, tempUint);

						    uncertainty = 10*(aux - 1); // ETSI TS 123.032 : C(((1+x)^k) -1);  x = 0.1; C= 10

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintySemiMinor, tempUint);

							Math::Pow(aux, 1.1, tempUint);

							uncertainty = uncertainty > (10*(aux - 1))? uncertainty : (10*(aux - 1));

							position.SetHorizontalAccuracy(uncertainty);

							// Get vertical uncertainty, convert to meters and set Vertical Accuracy

							ellipsoidReader.GetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintyAltitude, tempUint);

							Math::Pow(aux,1.025, tempUint);

						    uncertainty = 45*(aux - 1); //ETSI TS 123.032; C(((1+x)^k) -1); C=45; x=0.025

							position.SetVerticalAccuracy(uncertainty);

							positionInfo.SetPosition(position);

							const TPositionModuleId id = {KSuplv1UidValue};

							positionInfo.SetModuleId(id);

							positionInfo.SetUpdateType(EPositionUpdateGeneral);

							positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

							positionInfo.SetPositionModeReason(EPositionModeReasonNone);

							refLocReader.Close();

							// Send the position to LBS

							iGateway.NetworkLocationInd(aSessionId, positionInfo);

							}

						}

					}

				}

			}

		// Check if all of the assistance data types expected from the machine sending this

		// assistance data report are being reported. Send to LBS an error for the missing

		// assistance data types if they are not being collected from another machine.

		if (MLbsNetworkProtocolObserver::EServiceSelfLocation == aStateMachine)

			{

			if (aDataReportMask != iMoLrRequestedDataMask)

				{

				// Some data types are missing from the report. Pick those not being

				// taken care of by the MTLR state machine.

				missingDataTypes = iMoLrRequestedDataMask & ~aDataReportMask & ~iMtLrRequestedDataMask;

				}

			// No longer expecting assistance data from this machine

			iMoLrRequestedDataMask = KAssistDataEmpty;			

			}

		else if (MLbsNetworkProtocolObserver::EServiceMobileTerminated == aStateMachine)

			{		

			if (aDataReportMask != iMtLrRequestedDataMask)

				{

				// Some data types are missing from the report. Pick those not being

				// taken care of by the MOLR state machine.

				missingDataTypes = iMtLrRequestedDataMask & ~aDataReportMask & ~iMoLrRequestedDataMask;

				}

			// No longer expecting assistance data from this machine

			iMtLrRequestedDataMask = KAssistDataEmpty;

			}

		if (KAssistDataEmpty != missingDataTypes)

			{

			RLbsAssistanceDataBuilderSet dummyAssistanceData; //ignored by LBS when error is not KErrNone

			iGateway.AssistanceDataInd(missingDataTypes, dummyAssistanceData, KErrNotFound);

			}

		// Send received assistance data to LBS

		iGateway.AssistanceDataInd(aDataReportMask, aAssistanceData, KErrNone);

		// Remember this report for one second to guard agains this report

		// crossing in transit with a request from LBS which includes some

		// of the assitance data types being reported.

		iReportedDataMask = iReportedDataMask | aDataReportMask;

		if (iAssistDataReportTimer->IsActive())

			{

			iAssistDataReportTimer->Cancel();

			}

		iAssistDataReportTimer->EventAfter(TTimeIntervalSeconds(KAssistDataReportTimerDurationInSec), KAssistDataReportTimer);

		}

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::AssistanceDataReport() End\n");

	}

/** Set a machine as able to handle assistance data requests

This method is called by the Protocol Manager when it detects that a SUPL state machin

has sent a Location Request to LBS (which signals the point when it must/can received

an assistance data request)

*/

void CSuplAssistanceDataManager::MachineReadyForAssistanceDataRequest(const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aStateMachine)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::MachineReadyForAssistanceDataRequest() Begin\n");

	// Add this machine to the "ready" state machines mask

	iReadyMachinesMask = iReadyMachinesMask | aStateMachine;

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::MachineReadyForAssistanceDataRequest() End\n");

	}

/** Inform that a state machine is no longer active

This method is called by the Protocol Manager when it detects that a SUPL state machine

has terminated. If any assistance data were expected from this machine, an assistance data

report with KErrNotFound is sent to LBS for those assistance data types.

*/

void CSuplAssistanceDataManager::MachineTerminated(const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aStateMachine)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::MachineTerminated() Begin\n");

	TLbsAsistanceDataGroup orphanedDataRequestMask = KAssistDataEmpty;

	// Remove this machine from the "ready" state machines mask

	iReadyMachinesMask = iReadyMachinesMask &  ~aStateMachine;

	// If any assistance data was being collected from the machine (and not being collected from

	// another machine), a failure to collect those assistance data types must be reported to LBS 

	if ( (MLbsNetworkProtocolObserver::EServiceSelfLocation == aStateMachine)

		&& (KAssistDataEmpty != iMoLrRequestedDataMask))

		{

		orphanedDataRequestMask = iMoLrRequestedDataMask & ~iMtLrRequestedDataMask;

		}

	else if ( (MLbsNetworkProtocolObserver::EServiceMobileTerminated == aStateMachine)

			&& (KAssistDataEmpty != iMtLrRequestedDataMask))

		{

		orphanedDataRequestMask = iMtLrRequestedDataMask & ~iMoLrRequestedDataMask;

		}

	// Add the pending assistance data to the orphaned mask and clear the pending mask

	orphanedDataRequestMask = orphanedDataRequestMask | iPendingDataMask;

	iPendingDataMask = KAssistDataEmpty;

	if (KAssistDataEmpty != orphanedDataRequestMask)

		{

		RLbsAssistanceDataBuilderSet dummyAssistanceData; //ignored by LBS when error is not KErrNone

		iGateway.AssistanceDataInd(orphanedDataRequestMask, dummyAssistanceData, KErrNotFound);

		}

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::MachineTerminated() End\n");

	}

/** Timer expired callback.

This is used for clearing the reportedassistance

data mask one second after sending the assistance

data to LBS.

@param aTimerId The timer event identifier.

*/

void CSuplAssistanceDataManager::OnTimerEventL(TInt aTimerId)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::OnTimerEventL() Begin\n");

	// Perform relevant action for the expired timer

	switch (aTimerId)

		{

		// Additional assistance data timer

		case KAssistDataReportTimer:

			iReportedDataMask = KAssistDataEmpty;

			break;

		// Ignore unknown timer events

		default:

			break;

		};

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::OnTimerEventL() End\n");

	}

/** Timer callback error handler.

This is called if the timer expiry callback leaves.

@param aTimerId The timer event identifier.

@param aError Error value.

*/

TInt CSuplAssistanceDataManager::OnTimerError(TInt /*aTimerId*/, TInt aError)

	{

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::OnTimerError() Begin\n");

	SUPLLOG(ELogP1, "CSuplAssistanceDataManager::OnTimerError() End\n");

	return aError;

	}