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

//

#include <e32std.h>

#include <e32property.h>

// LBS-specific

#include <lbs.h>

#include <lbs/lbsadmin.h>

#include <lbs/lbslocerrors.h>

#include <lbs/lbslocclasstypes.h>

#include "nrhpanic.h"

#include "lbsdevloggermacros.h"

#include "lbsqualityprofile.h"

#include "privacyandlocationrequesthandler.h"

// Special 'invalid session' SessionId.

const TLbsNetSessionIdInt KInvalidSessionId(TUid::Uid(0), 0);

const TPositionModuleInfo::TTechnologyType KTerminalAssistedMode = (TPositionModuleInfo::ETechnologyNetwork |

																	TPositionModuleInfo::ETechnologyAssisted);

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

// 

// ----------------------- Class CPrivacyAndLocationHandler --------------------

//

// State Machine class which owns the states of the Privacy and Location Handler

//

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

//

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

// CPrivacyAndLocationHandler::NewL

// Description: CPrivacyAndLocationHandler static constructor 

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

//

CPrivacyAndLocationHandler* CPrivacyAndLocationHandler::NewL(CNGMessageSwitch& aMessageSwitch,

											CLbsAdmin& aLbsAdmin,

											RLbsNetworkRegistrationStatus& aNetRegStatus)

	{

	CPrivacyAndLocationHandler* self; 

	self = new (ELeave) CPrivacyAndLocationHandler(aMessageSwitch, aNetRegStatus);

	CleanupStack::PushL(self);

	self->ConstructL(&aLbsAdmin);

	CleanupStack::Pop(self);

	return(self);	

	}

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

// CPrivacyAndLocationHandler::CPrivacyAndLocationHandler

// Description: CPrivacyAndLocationHandler constructor 

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

//

CPrivacyAndLocationHandler::CPrivacyAndLocationHandler(CNGMessageSwitch& aMessageSwitch, 

													   RLbsNetworkRegistrationStatus& aNetRegStatus)

:	iNetRegStatus(aNetRegStatus),

	iMessageSwitch(&aMessageSwitch),

	iNumActiveSessions(0)

	{	

	}

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

// CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler

// Description: CPrivacyAndLocationHandler destructor 

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

//

CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler()

	{

	// If iEmergencyFsm has been used by any outstanding request,

	// it needs to be removed before calling ResetAndDestroy(),

	// otherwise it will get double-deleted when delete iEmergencyFsm

	// is called.

	TInt index = iFsmArray.Find(iEmergencyFsm);

	if (index >= 0)

		{

		iFsmArray.Remove(index);

		}

	iFsmArray.ResetAndDestroy();

	delete iEmergencyFsm;

    delete iAgpsInterface;

    delete iPrivacyHandler;

	}

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

// CPrivacyAndLocationHandler::ConstructL

// Description: CPrivacyAndLocationHandler second-phase constructor.

//              Creates the states of the system and the Privacy Handler.

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

//

const TInt KLbsDefaultMaxNumLocationRequests   = 4;

void CPrivacyAndLocationHandler::ConstructL(CLbsAdmin* aLbsAdmin)

	{

	iLbsAdmin = aLbsAdmin;

	iPrivacyHandler = CPrivacyHandler::CreateL(this, *iLbsAdmin, iNetRegStatus);

	iMessageSwitch->RegisterObserver(this);

	// Get the behaviour mode and device gps mode capabilities

	TInt err = iLbsAdmin->Get(KLbsSettingBehaviourMode, iLbsBehaviourMode);

	if (err != KErrNone)

		{

		iLbsBehaviourMode = CLbsAdmin::ELbsBehaviourCustom1;

		}

	// get 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;

		}

	err = iLbsAdmin->Get(KLbsSettingMaximumExternalLocateRequests, iMaxNumSessions);

	if (err != KErrNone)

		{

		iMaxNumSessions = KLbsDefaultMaxNumLocationRequests;

		}

	iAgpsInterface = CAgpsInterfaceHandler::NewL(*this, *iLbsAdmin, iNetRegStatus);

#ifdef NRH_UNIT_TEST

	// For testing use the Uid of the dummy NG

	const TInt KTestNgUidInt = 0x1028226B;

	const TUid KTestNgUid = {KTestNgUidInt};

	iProtocolModuleUid = KTestNgUid;

#else

	ReadProtocolModuleAdminSetting();

#endif

	iEmergencyFsm = CLbsPrivLocFsm::NewL(*this, KInvalidSessionId);

	// Reserve space for FSMs. Note "+1" because a pointer to the emergency Fsm gets added to this array

	iFsmArray.ReserveL(iMaxNumSessions+1);

	CLbsAdmin::TSpecialFeature specialFeature(CLbsAdmin::ESpecialFeatureOff);

	err = iLbsAdmin->Get(KLbsSpecialFeatureIntermediateFutileUpdate, specialFeature);

	if (err != KErrNone)

		{

		LBSLOG_ERR2(ELogP3, "Failed to get KLbsSpecialFeatureIntermediateFutileUpdate (err %d)", err);

		}

	LBSLOG2(ELogP3, "Using KLbsSpecialFeatureIntermediateFutileUpdate = %d", specialFeature);

	iSpecialFeatureIntermediateFutileUpdate = (specialFeature == CLbsAdmin::ESpecialFeatureOn) ? ETrue : EFalse;

	}

/**

Reads the Uid of a current Protocol Module from the Admin Settings.

*/

void CPrivacyAndLocationHandler::ReadProtocolModuleAdminSetting()

	{

	LBSLOG(ELogP1, "CPrivacyAndLocationHandler::ReadProtocolModuleAdminSetting()");

	TLbsProtocolModuleId protUid(KLbsProtocolNullModuleId);

	TInt err = iLbsAdmin->Get(KLbsSettingHomeProtocolModule, protUid);

	if (err != KErrNone)

		{

		LBSLOG_ERR2(ELogP4, "Failed to get KLbsSettingHomeProtocolModule (err %d)", err);

		}

	iProtocolModuleUid = protUid;

	}

/** Compares sessionId for RPointerArray::Find().

*/

TBool CPrivacyAndLocationHandler::IsSessionIdEqual(

		const TLbsNetSessionIdInt* aSessionId,

		const CLbsPrivLocFsm& aFsm)

	{

	return (*aSessionId == aFsm.SessionId());

	}

/** Compares session type for RPointerArray::Find().

*/

TBool CPrivacyAndLocationHandler::IsSessionTypeEqual(

		const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt* aSessionType,

		const CLbsPrivLocFsm& aFsm)

	{

	return (*aSessionType == const_cast<CLbsPrivLocFsm&>(aFsm).SessionType());

	}

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

// CPrivacyAndLocationHandler::LookupFsm

// Description: Lookup CLbsPrivLocFsm object by session ID.

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

//

CLbsPrivLocFsm* CPrivacyAndLocationHandler::LookupFsm(const TLbsNetSessionIdInt& aSessionId)

	{

	LBSLOG2(ELogP3, "LookupFsm session=%d", aSessionId.SessionNum());

	// Standard sessions always use the standard state machines.

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

	if (index >= 0)

		{

		LBSLOG(ELogP3, "LookupFsm: Existing standard FSM found");

		return iFsmArray[index];

		}

	else

		{

		LBSLOG(ELogP3, "LookupFsm: No standard FSM found");

		return NULL;		

		}

	}

/** Get a new state machine to use for a new request.

The state machine can either be re-using an existing FSM,

or allocating a new one from the heap or, for emergencies one thats was prepared earlier is used.

*/

CLbsPrivLocFsm* CPrivacyAndLocationHandler::GetNewFsm(

		const TLbsNetSessionIdInt& aSessionId,

		TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType,

		TBool aEmergency)

	{

	LBSLOG2(ELogP3, "LookupFsm session=%d", aSessionId.SessionNum());

	CLbsPrivLocFsm* fsm(NULL);

	// If this is an emergency request, use the emergency FSM  

	// Note, we only have to support ONE emergency at a time

	// this implies that only one Protcol module may deal with emergencies

	// So we do NOT support TWO emergencies .. one from each of the PMs

	// Note: only MT-LR or NI-LR requests can be emergency requests.

	if (aEmergency

		&& (aSessionType == MLbsNetworkProtocolObserver::EServiceMobileTerminated

		|| aSessionType == MLbsNetworkProtocolObserver::EServiceNetworkInduced))

		{					

		TInt index = iFsmArray.Find(iEmergencyFsm);

		if (index >= 0)

			{

			iFsmArray.Remove(index);

			iNumActiveSessions--;

			}

		// clean out Fsm

		iEmergencyFsm->RefPosProcessed() = EFalse;

		iEmergencyFsm->LocReqReceived() = EFalse;

		iEmergencyFsm->LocationFixReceived()= EFalse;

		iEmergencyFsm->TapMode() = EFalse;

		iEmergencyFsm->WasPrivacyResponseReceivedStateExited() = EFalse;

		iEmergencyFsm->NetSessionId()= aSessionId;

		fsm = iEmergencyFsm;

		}

	else

		{

		if (iNumActiveSessions <= iMaxNumSessions)

			{

			// Create a new session to handle this privacy request

			LBSLOG2(ELogP3, "Creating FSM for new standard request %d",aSessionId.SessionNum());

			TRAPD(err, fsm = CLbsPrivLocFsm::NewL(*this, aSessionId)); 

			if (err != KErrNone)

				{

				LBSLOG_ERR2(ELogP3, "Failed to create new FSM, error code : %d", err);

				}

			}

		else

			{

			LBSLOG_ERR3(ELogP3, "Session start rejected! iNumActiveSessions=%d > iMaxNumSessions=%d", iNumActiveSessions, iMaxNumSessions);

			}

		}

	if (fsm)

		{

		// Add the state machine to the buffer.

		iNumActiveSessions++; // conceptually, a session starts when a Fsm is created for it

		}

	return fsm;

	}

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

// CPrivacyAndLocationHandler::PrivacyHandler

// Description: Return a pointer to the privacy handler implementation

//              (controller or notifier).

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

//

CPrivacyHandler* CPrivacyAndLocationHandler::PrivacyHandler()

	{

	return iPrivacyHandler;

	}

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

// CPrivacyAndLocationHandler::MessageSwitch

// Description: Return a pointer to the Network Gateway Message Switch

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

//

CNGMessageSwitch* CPrivacyAndLocationHandler::MessageSwitch()

	{

	return iMessageSwitch;

	}

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

// CPrivacyAndLocationHandler::LbsAdmin

// Description: Return a pointer to the Admin settings database

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

//

CLbsAdmin* CPrivacyAndLocationHandler::LbsAdmin()

	{

	return iLbsAdmin;

	}

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

// CPrivacyAndLocationHandler::SetServerObserver

// Description: Store a pointer to the NRH server which comunicates with the 

// Privacy Controller.

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

//

void CPrivacyAndLocationHandler::SetServerObserver(MLbsSessionObserver* aNrhServer)

    {

    PrivacyHandler()->SetServerObserver(aNrhServer);

    }

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

// CPrivacyAndLocationHandler::OnRespondNetworkLocationRequest

// Description: Called by the Privacy Handler to report the result of a privacy

// check. Handling of the response is delegated to the current state.

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

//

void CPrivacyAndLocationHandler::OnRespondNetworkLocationRequest(const TLbsNetSessionIdInt& aRequestId, 

                            TLbsNetworkEnumInt::TLbsPrivacyResponseInt aRequestResult,

                            TInt aResponseReason)

	{

	LBSLOG2(ELogP3, "Received response %d to privacy request", aRequestResult);

	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

	if (NULL != fsm)

		{

		fsm->OnRespondNetworkLocationRequest(aRequestId, aRequestResult, aResponseReason);

		}

	else

		{

		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

		}

    }

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

// CPrivacyAndLocationHandler::OnCancelNetworkLocationRequest

// Description: Called by the Privacy Handler to report that a privacy check 

// has been rejected. This may occur after it has already been accepted.

// Handling of the response is delegated to the current state.

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

//

void CPrivacyAndLocationHandler::OnCancelNetworkLocationRequest(const TLbsNetSessionIdInt& aRequestId)

    {

	LBSLOG2(ELogP3, "Received cancellation to privacy request %d", aRequestId.SessionNum());

	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

	if (NULL != fsm)

		{

		fsm->OnCancelNetworkLocationRequest(aRequestId);

		}

	else

		{

		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

		}

    }

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

// CPrivacyAndLocationHandler::OnMTLRRequest

// Description: The Message Switch has forwarded a request to start an MTLR 

// session.

// Handling of the request is delegated to the current state.

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

//

void CPrivacyAndLocationHandler::OnMTLRRequest(const TLbsNetSessionIdInt& aSessionId,

					   TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

					   TBool aIsEmergency,

					   const TLbsExternalRequestInfo& aExternalRequestInfo,

					   const TLbsNetPosRequestPrivacyInt& aNetPosRequestPrivacy)

	{

	LBSLOG2(ELogP3, "Received privacy request with id %d", aSessionId.SessionNum());

	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

	if (fsm==NULL)

		{

		fsm = GetNewFsm(aSessionId, aSessionType, aIsEmergency);

		}

	if (NULL != fsm)

		{

		fsm->OnMTLRRequest(aSessionId, 

						   aSessionType, 

						   aIsEmergency, 

						   aExternalRequestInfo, 

						   aNetPosRequestPrivacy);

		}

	else

		{					

		// Failed to create a state machine for this request,

		// so simply reply with a privacy rejection.

		iMessageSwitch->SendMTLRResponse(aSessionId, 

										 TLbsNetworkEnumInt::EPrivacyResponseRejected,

										 KErrGeneral, EFalse); // can't be an emergency cuase we know we have a Fsm for these!

		}

	}

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

// CPrivacyAndLocationHandler::OnSessionComplete

// Description: The Message Switch has reported that the session is

// over (complete or aborted due to some error).

// Handling of the message is delegated to the current state.

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

//

void CPrivacyAndLocationHandler::OnSessionComplete(

									const TLbsNetSessionIdInt& aSessionId,

									TInt aReason)

	{

	LBSLOG3(ELogP3, "Received Session Complete for id %d, reason %d", aSessionId.SessionNum(), aReason);

	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

	if (NULL != fsm)

		{

		fsm->OnSessionComplete(aSessionId, aReason);

		// The session complete marks the end of a session.

		TInt index = iFsmArray.Find(fsm);

		if (index != KErrNotFound)

			{ 

			if (fsm->SessionType()== TLbsNetworkEnumInt::EServiceSelfLocation)

				{

				iMolRFsm = NULL;

				}

			else if (fsm->SessionType()== TLbsNetworkEnumInt::EServiceTransmitThirdParty)

				{

				iX3pFsm = NULL;

				}

			// We should never delete the emergency FSM.

			iFsmArray.Remove(index);

			iNumActiveSessions--;

			if (fsm != iEmergencyFsm)

				{

				delete fsm;

				}

			}

		}

	else

		{

		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

		}

	}

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

// CPrivacyAndLocationHandler::OnNetLocRequest

// Description: The Message Switch has passed on a request for a position update

// Handling of the request is delegated to the current state.

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

//

void CPrivacyAndLocationHandler::OnNetLocRequest(

						const TLbsNetSessionIdInt& aSessionId, 

						const TLbsNetPosRequestMethodInt& aPosRequestMethod,

						TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

						TBool aIsEmergency,

						const TLbsNetPosRequestQualityInt& aQuality)

	{

	LBSLOG2(ELogP3, "Received position update request for id %d", aSessionId.SessionNum());

	TLbsNetSessionIdInt sessionId;

	TPositionInfo    posInfo;

	TPosition		 pos;

	TTime 			 timeStamp;

	TInt 			 err;

	TBool tapMode = EFalse;

	TInt numMethods = aPosRequestMethod.NumPosMethods();

    if (numMethods==1)

    	{

    	TLbsNetPosMethodInt netPosMethod;

    	aPosRequestMethod.GetPosMethod(0,netPosMethod);

    	if (netPosMethod.PosMode()== (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted))

    		{

    		tapMode = ETrue;

    		}

    	}

	// This filtering used to be in the NG Message Switch, but has been moved

	// here to get an access to the ref position bus

	if( (aSessionType == TLbsNetworkEnumInt::EServiceNetworkLocation) && !tapMode)

		{

		// A Network-based location request generates a location 

		// request to the network request handler, but there's no point 

		// passing it any further - the AGPS manager & privacy 

		// controller aren't interested.

		// Simply return the saved reference location

		err = iMessageSwitch->GetNetworkReferencePosition(aSessionId, posInfo);			

		posInfo.GetPosition(pos);

		timeStamp = pos.Time();

		TLbsNetPosRequestQualityInt dummyQuality;

		MessageSwitch()->SendNetLocResponse(aSessionId, err, dummyQuality, posInfo, timeStamp, EFalse);

		}

	else

		{

		// we note that a self locate MoLr session can be implicitly

		// cancelled by the start of a new session for a new client.