/*

* Copyright (c) 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:

*

*/

#include <e32base.h>

#include <e32std.h>

// LBS-specific

#include <lbs.h>

#include <lbs/lbsx3p.h>

#include "lbsdevloggermacros.h"

#include "lbsnrhserver.h"

#include "x3phandler.h"

#include "ngmessageswitch.h"

const TInt KReservedRequestsNum = 4;

CX3pHandler::CX3pHandler(CNGMessageSwitch& aMessageSwitch, MX3pStatusHandler& aX3pStatusHandler, CLbsAdmin& aLbsAdmin) : 

	iMessageSwitch(aMessageSwitch),

	iNextSessionId(1),

	iAdmin(aLbsAdmin),

	iReceivedFinalNetPosInfo(EFalse),

	iX3pStatusHandler(aX3pStatusHandler)

    {

    }

CX3pHandler* CX3pHandler::NewL(CNGMessageSwitch& aMessageSwitch, MX3pStatusHandler& aX3pStatusHandler, CLbsAdmin& aLbsAdmin)

    {

	CX3pHandler* self;

	self = new (ELeave) CX3pHandler(aMessageSwitch, aX3pStatusHandler, aLbsAdmin);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);	

    }

CX3pHandler::~CX3pHandler()

	{

	iX3pObservers.Close();

	iX3pRequests.ResetAndDestroy();

	}

void CX3pHandler::ConstructL()

    {

	iMessageSwitch.RegisterObserver(this);

	TInt err = iAdmin.Get(KLbsSettingBehaviourMode, iLbsBehaviourMode);

	if (err != KErrNone)

		{

		iLbsBehaviourMode = CLbsAdmin::ELbsBehaviourCustom1;

		}	

	// get device mode capabilities:

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

	if(err != KErrNone)

		{

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

		iDeviceGpsModeCaps = TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB;

		}

	iX3pRequests.ReserveL(KReservedRequestsNum);

	iX3pObservers.ReserveL(KReservedRequestsNum);

    iActiveRequestIndex = KErrNotFound;

    UpdateX3pStatus();

    }

void CX3pHandler::TransmitLocationRequestL(const TDesC& aDestinationID,

										   TUint aTransmitPriority, 

										   const TLbsTransmitPositionOptions& aTransmitOptions,

										   TLbsNetSessionIdInt& aSessionId)

	{

	LBSLOG(ELogP1, "CX3pHandler::TransmitLocationRequestL:");

	// Generate a new session Id

	TLbsNetSessionIdInt sessionId(KLbsNetRequestHandlerUid, iNextSessionId++);

    // Create an instance for this request.

    CX3pRequest* newRequest = 0;

	newRequest = CX3pRequest::NewL(this, sessionId,

								   aDestinationID,

								   aTransmitPriority,

								   aTransmitOptions);

	CleanupStack::PushL(newRequest);

	iX3pRequests.AppendL(newRequest);

	CleanupStack::Pop(newRequest);

	// Write the session Id back to the caller

	aSessionId = sessionId;

    //

    // The timeout (if specified) runs from the time the request was made, so 

    // start the request timer now, even if we're not going to action the 

    // request yet

    //

	newRequest->StartTimer();

	//

	// The new request has been added. Now see if there is a request being

	// actioned at the moment. If not, start this one

	//

	TInt newRequestIndex = iX3pRequests.Count() - 1;

	TInt currentRequestIndex = iActiveRequestIndex;

	if(iActiveRequestIndex == KErrNotFound)

	    {

		currentRequestIndex = newRequestIndex;

	    }

	else

	    {

        // 

        // If there is an active request, see if its priority is lower than 

        // the new one. If so, action the new one.

        // The Network Gateway handles the necessary cancellations.

        //

        if(iActiveRequest->TransmitPriority() > aTransmitPriority)

            {

            LBSLOG3(ELogP2, "New X3P (priority %d) overrides currently active X3P (priority %d)", 

            				aTransmitPriority, 

            				iActiveRequest->TransmitPriority());

		    currentRequestIndex = newRequestIndex;

            }

	    }

	if(currentRequestIndex != iActiveRequestIndex)

	    {

	    iActiveRequestIndex = currentRequestIndex;

		ActivateRequest();

	    }

	}

void CX3pHandler::TransmitLocationCancel(const TLbsNetSessionIdInt& aSessionId)

	{

	LBSLOG(ELogP1, "CX3pHandler::TransmitLocationCancel:");

	// There is a chance that we get a 'cancel' for an X3P request

	// that has already finished normally, so first check that

	// the sessionId is one that is currently active.

	TInt requestIndex = FindSessionById(aSessionId);

	if(requestIndex != KErrNotFound)

		{

		// Forward the cancel message onto the network

		iMessageSwitch.SendX3pCancel(aSessionId, KErrCancel);

		}

	}

void CX3pHandler::ActivateRequest()	    

	{

	if(iActiveRequestIndex != KErrNotFound)

		{

		iActiveRequest = iX3pRequests[iActiveRequestIndex];

		// Get the technology type to use for this request from the admin settings.

		TPositionModuleInfo::TTechnologyType mode;

		GetAdminTechnologyType(mode);

		TLbsNetPosRequestOptionsTechnologyInt options;

		options.SetPosMode(mode);

		iMessageSwitch.SendX3pRequest(iActiveRequest->SessionId(),

									  iActiveRequest->DestinationId(),

									  iActiveRequest->TransmitPriority(),

									  options);

		// Reset the final network position flag

		iReceivedFinalNetPosInfo = EFalse;

		}

	}

/* Called when a pending request has timed out before it was completed.

 */

void CX3pHandler::OnRequestTimeout(const TLbsNetSessionIdInt& aTimedOutRequestId)

    {

	if(aTimedOutRequestId.SessionNum() != 0)

		{

		HandleTimedOutRequest(aTimedOutRequestId);

		}

    }

/*

*/

TInt CX3pHandler::HighestPriorityIndex()

    {

    TInt index = KErrNotFound;

    const TInt count = iX3pRequests.Count();

    if (count > 0)

    	{

    	CX3pRequest* highPriorityReq = iX3pRequests[0];

    	index = 0;

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

    		{

    		CX3pRequest* request = iX3pRequests[i];

    		if (request->TransmitPriority() > 

    			highPriorityReq->TransmitPriority())

    			{

    			index = i;

    			highPriorityReq = request;

    			}

    		}

   		}

	return (index);

	}

/* Look through the array of requests to find the one with a session Id

   equal to the input aSessionId.

   Set the reference parameter aSessionIndex to the array index of the

   request, and return a pointer to the request.

   If no request is found with the specified aSessionId, then return NULL.

*/

TInt CX3pHandler::FindSessionById(const TLbsNetSessionIdInt& aSessionId)

    {

    TInt retVal = KErrNotFound;

	TInt requestCount = iX3pRequests.Count();

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

	    {

		if(iX3pRequests[i]->SessionId() == aSessionId)

		    {

		    retVal = i;

		    break;

		    }

	    }

	return(retVal);    

    }

/* Search the array following a delete to find the index

   of the currently active request, looking for it by its session ID.

*/

void CX3pHandler::RecalculateActiveIndex(const TLbsNetSessionIdInt& aSessionId)

    {

	iActiveRequestIndex = FindSessionById(aSessionId);

    }

void CX3pHandler::HandleTimedOutRequest(const TLbsNetSessionIdInt& aRequestId)

    {

	// Send a cancel message to the network,

	//  with KErrTimedOut as the reason

	iMessageSwitch.SendX3pCancel(aRequestId, KErrTimedOut);	

    }

void CX3pHandler::HandleCompletedRequest(const TLbsNetSessionIdInt& aRequestId, TInt aReason)

    {

    TInt err = aReason;

    TBool isTerminalAssistedPos = EFalse;

    //

    // There's a possibility this request ID won't be found, if a Transmit

    // Cancel was received after the request had been sent off. If this

    // is the case, just ignore the completion.

    //

	TInt requestIndex = FindSessionById(aRequestId);

	if(requestIndex != KErrNotFound)

		{

		if (!iReceivedFinalNetPosInfo)

			{

			TInt ret = iMessageSwitch.GetNetworkFinalPosition(aRequestId, iFinalNetPosInfo);

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

				{

				err = ret;

				}

			}

		// Add the ID of the module supplying the update. This is either 

		// the GPS Location Manager or the Network Location Manager (if 

		// the Position Mode is not one of those below, leave the Module Id

		// unchanged).

		TPositionModuleInfo::TTechnologyType posMode = iFinalNetPosInfo.PositionMode();

		if(posMode == (TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted))

			{

			iFinalNetPosInfo.SetModuleId(KLbsGpsLocManagerUid);

			}

		else

			if(posMode == (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted))

				{

				iFinalNetPosInfo.SetModuleId(KLbsNetLocManagerUid);

				isTerminalAssistedPos = ETrue;

				}

		// It may be that the network has modified the position update, 

		// so we need to check that it satisfies the quality criteria and report

		// it if not.

		if(aReason == KErrNone) // network thinks it's OK

			{

			if(!iX3pRequests[requestIndex]->FixIsAccurate(iFinalNetPosInfo, isTerminalAssistedPos))

				{

				err = KPositionQualityLoss;

				}

			}

		// Notify observers of the completed session

		const TInt count = iX3pObservers.Count();

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

			{

			iX3pObservers[i]->OnTransmitLocationComplete(

									aRequestId, 

									iFinalNetPosInfo,

									err);

			}

		// Remove the request from the list

		delete iX3pRequests[requestIndex];

		iX3pRequests.Remove(requestIndex);

		// If the completed request was being actioned, start the next

		// one if there is one.

		if(requestIndex == iActiveRequestIndex)

			{

			iActiveRequestIndex = HighestPriorityIndex();

			if(iActiveRequestIndex != KErrNotFound)

				{

				ActivateRequest();

				}

		}

		else

			{

			// The array has been changed by the removal of an entry.

			// Make sure iActiveRequestIndex is correct for the active

			// entry.

			TLbsNetSessionIdInt activeSessionId = iActiveRequest->SessionId();

			RecalculateActiveIndex(activeSessionId);

			}    

		}

 	// Tell the AGPS interface handler the current state

 	// of the X3P handler.

 	UpdateX3pStatus();

	}

/*

*/

void CX3pHandler::OnMTLRRequest(const TLbsNetSessionIdInt& /*SessionId*/,

				  TLbsNetworkEnumInt::TLbsNetProtocolServiceInt  /*aSessionType*/, 

				   TBool /*aIsEmergency*/,

				   const TLbsExternalRequestInfo& /*aExternalRequestInfo*/,

				   const TLbsNetPosRequestPrivacyInt& /*aNetPosRequestPrivacy*/)

	{

	// We do not need to know about MT-LR requests so ignore this call.

	}

void CX3pHandler::OnNetLocResponse(const TLbsNetSessionIdInt& aSessionId,

								 const TLbsNetPosRequestQualityInt& aQuality)

	{

	// Check if this Network Location Response

	// is for a X3P that is currently in progress

	TInt requestIndex = FindSessionById(aSessionId);

	if (requestIndex != KErrNotFound)

		{

		iX3pRequests[requestIndex]->SetRequestQuality(aQuality);

		}

	}

/*

*/

void CX3pHandler::OnSessionComplete(const TLbsNetSessionIdInt& aSessionId, TInt aReason)

	{

	// Check if this Network Location Response

	// is for a X3P that is currently in progress

	TInt requestIndex = FindSessionById(aSessionId);

	if (requestIndex != KErrNotFound)

		{

		HandleCompletedRequest(aSessionId, aReason);

		}

	}

/* Called during a TransmitLocation request, at the point where the network provides the

handset with a network-based Reference Location.

The Reference Location (aRefPosInfo) will be sent back to the client's session, and the session

will forward it back to the client if the client wants it.

Values of aIsEmengency and aQuality are not relevant for the CX3pHandler (they are for

other observers)

*/

void CX3pHandler::OnNetLocRequest(const TLbsNetSessionIdInt& aSessionId,

					const TLbsNetPosRequestMethodInt& aNetPosMethod,

					 TLbsNetworkEnumInt::TLbsNetProtocolServiceInt /*aSessionType*/, 

					 TBool /*aIsEmergency*/,

					 const TLbsNetPosRequestQualityInt& /*aQuality*/)

	{

	TBool hybridMode = EFalse;

	TLbsNetPosMethodInt posMethod;

	const TPositionModuleInfo::TTechnologyType KTerminalAssistedMode = (

				TPositionModuleInfo::ETechnologyNetwork |

				TPositionModuleInfo::ETechnologyAssisted);

	// Does the hardware support hybrid mode?

	if(iDeviceGpsModeCaps & TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB )

		{

		TInt methodCount = aNetPosMethod.NumPosMethods();

		for(TInt i = 0; (i < methodCount) && !hybridMode; ++i)

			{

			aNetPosMethod.GetPosMethod(i, posMethod);

			hybridMode = (posMethod.PosMode() & KTerminalAssistedMode) == KTerminalAssistedMode;

			}

		}

	// Custom1: If the hybrid mode and a first request, then re-start the timer

	if (hybridMode 

		&& (aSessionId.SessionOwner() == KLbsNetRequestHandlerUid) 

		&& (iLbsBehaviourMode == CLbsAdmin::ELbsBehaviourCustom1))

		{

		TInt requestIndex = FindSessionById(aSessionId);

		if(requestIndex != KErrNotFound)

			{

			// The timer can be re-started only once

			iX3pRequests[requestIndex]->ReStartTimerOnce();

	   		}

	   	}

	}

/** Called when a reference position arrives from the network.

*/

void CX3pHandler::OnNetLocReferenceUpdate(const TLbsNetSessionIdInt& aSessionId, 

								 		  const TPositionInfoBase& aPosInfo)

	{

    // There's a possibility this request ID won't be found, if a Transmit

    // Cancel was received after the request had been sent off. If this

    // is the case, just ignore the completion.

	if (aSessionId.SessionOwner() == KLbsNetRequestHandlerUid)

		{

		iRefPosInfo = static_cast<const TPositionInfo&>(aPosInfo);

		TInt requestIndex = FindSessionById(aSessionId);

		if(requestIndex != KErrNotFound)

			{

			iRefPosInfo.SetModuleId(KLbsGpsLocManagerUid);

			iRefPosInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

			iRefPosInfo.SetPositionModeReason(EPositionModeReasonNone);

			iRefPosInfo.SetUpdateType(EPositionUpdateGeneral);

	   		// Notify observers of the completed session

	   		const TInt count = iX3pObservers.Count();

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

	   			{

	   			iX3pObservers[i]->OnReferenceLocationAvailable(

	   									aSessionId, 

	  									iRefPosInfo);

	   			}

	   		}

	   	}	

	}

/** Callend when a final location arrives from the network.

*/

void CX3pHandler::OnNetLocFinalUpdate(

		const TLbsNetSessionIdInt& aSessionId, 

		const TPositionInfoBase& aPosInfo)

	{

	// If the final network position is for an active X3P, 

	// then store it for when the X3P is completed.

	TInt requestIndex = FindSessionById(aSessionId);

	if (requestIndex != KErrNotFound)

		{

		if (requestIndex == iActiveRequestIndex)

			{

			iReceivedFinalNetPosInfo = ETrue;

			iFinalNetPosInfo = static_cast<const TPositionInfo&>(aPosInfo);

			}

		}

	}

TInt CX3pHandler::OnTransmitPosition(const TDesC& aDestinationId,

									 TUint aTransmitPriority,

									 const TLbsTransmitPositionOptions& aTransmitOptions,

									 TLbsNetSessionIdInt& aSessionId)

	{

	TInt err(KErrNone);

	TRAP(err, TransmitLocationRequestL(aDestinationId, aTransmitPriority,

									   aTransmitOptions, aSessionId));

 	// Tell the AGPS interface handler the current state

 	// of the X3P handler.

 	UpdateX3pStatus();

	return err;

	}

void CX3pHandler::OnCancelTransmitPosition(const TLbsNetSessionIdInt& aSessionId)

	{

	TransmitLocationCancel(aSessionId);

	}

/* Add an observer (actually a client X3P subsession)

*/

void CX3pHandler::AddObserverL(MX3pHandlerObserver* aObserver)

 	{

 	iX3pObservers.AppendL(aObserver);

 	// Tell the AGPS interface handler the current state

 	// of the X3P handler.

 	UpdateX3pStatus();

 	}

/* Remove an observer (actually a client X3P subsession)

*/

void CX3pHandler::RemoveObserver(MX3pHandlerObserver* aObserver)

 	{

 	TInt index = iX3pObservers.Find(aObserver);

 	if (index != KErrNotFound)

 		{

 		iX3pObservers.Remove(index);

 		}

 	// Tell the AGPS interface handler the current state

 	// of the X3P handler.

 	UpdateX3pStatus();

 	}

/** Send the current X3P status to the status handler - for power mode advice.

*/