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

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

// protocol aspects of Test Protocol Module operation.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include <e32base.h>

#include <lbs/lbslocdatasourcegpsbase.h>

#include "cconfigmanager.h"

#include "cmolrstatemachine.h"

#include "cmtlrstatemachine.h"

#include "cx3pstatemachine.h"

#include "cnetlocstatemachine.h"

#include "cprotocolmanager.h"

#include "cassistdatamgr.h"

#include "lbsdevloggermacros.h"

#ifdef ENABLE_LBS_DEV_LOGGER

#include <lbs/lbsnetclasstypes.h>

#endif

/** The unique ID of this plug-in implementation.

This corresponds to the implementation UID specified in the .rss file

for this protocol module.

*/

const TInt KPluginUidValue = 0x10281D70;

const TUid KPluginUid = { KPluginUidValue };

/** Static constructor.

@param aGateway A reference to the protocol manager observer

@return A new instance of the CProtocolManager class

*/

CProtocolManager* CProtocolManager::NewL(MProtocolMgrObserver& aGateway)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/** Standard constructor.

@param aGateway A reference to the protocol manager observer

*/

CProtocolManager::CProtocolManager(MProtocolMgrObserver& aGateway)

: iGateway(aGateway), iLbsStatus(CLbsNetworkProtocolBase::ESystemStatusNone),

	iActiveServiceMask(MLbsNetworkProtocolObserver::EServiceNone)

	{

	iInternalSessionId.SetSessionOwner(KPluginUid);

	iInternalSessionId.SetSessionNum(0);

	LBSLOG(ELogP2, "CProtocolManager::CProtocolManager() CurrentOp --> EOpNone\n");

	iCurrentOp.iOperation = CConfigManager::EOpNone;

	iCurrentOp.iPriority = CConfigManager::EPriorityNone;

	}

/** Standard destructor.

*/

CProtocolManager::~CProtocolManager()

	{

	delete iAssistMgr;

	delete iNetLoc;

	delete iX3p;

	delete iMtLr;

	delete iMoLr;

	delete iConfig;

	delete iNetwork;

	}

/** Private second-stage constructor.

*/

void CProtocolManager::ConstructL()

	{

	iNetwork = CNetworkInterface::NewL(*this);

	iNetwork->Connect();

	iConfig = CConfigManager::NewL();

	iMoLr = CMoLrStateMachine::NewL(*this);

	iMtLr = CMtLrStateMachine::NewL(*this);

	iX3p = CX3pStateMachine::NewL(*this);

	iNetLoc = CNetLocStateMachine::NewL(*this);

	iAssistMgr = CAssistDataMgr::NewL();

	}

/** Identify active state machine

@param aActiveMachine A reference to a pointer that identifies the active

	state machine. This pointer is set to NULL if there is no active machine.

*/

void CProtocolManager::GetActiveStateMachine(CStateMachineBase*& aActiveMachine) const

	{

	//LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() \n");

	if (CStateMachineBase::EStateActive == iMtLr->State())

		{

		LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() Active Machine = MTLR\n");

		aActiveMachine = iMtLr;

		}

	else if (CStateMachineBase::EStateActive == iMoLr->State())

		{

		LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() Active Machine = MOLR\n");

		aActiveMachine = iMoLr;

		}

	else if (CStateMachineBase::EStateActive == iX3p->State())

		{

		LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() Active Machine = X3P\n");

		aActiveMachine = iX3p;

		}

	else if (CStateMachineBase::EStateActive == iNetLoc->State())

		{

		LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() Active Machine = NBLR\n");

		aActiveMachine = iNetLoc;

		}

	else

		{

		LBSLOG(ELogP2, "CProtocolManager::GetActiveStateMachine() No Active Machine\n");

		aActiveMachine = NULL;

		}

	}

/** Identify a state machine that is currently cancelling.

@param aCancellingMachine A reference to a pointer that identifies the cancelling

	state machine. This pointer is set to NULL if there is no cancelling machine.

*/

void CProtocolManager::GetCancellingStateMachine(CStateMachineBase*& aCancellingMachine) const

	{

	if (CStateMachineBase::EStateCancelling == iMtLr->State())

		{

		aCancellingMachine = iMtLr;

		}

	else if (CStateMachineBase::EStateCancelling == iMoLr->State())

		{

		aCancellingMachine = iMoLr;

		}

	else if (CStateMachineBase::EStateCancelling == iX3p->State())

		{

		aCancellingMachine = iX3p;

		}

	else if (CStateMachineBase::EStateCancelling == iNetLoc->State())

		{

		aCancellingMachine = iNetLoc;

		}

	else

		{

		aCancellingMachine = NULL;

		}

	}

/** Identify a state machine that is currently queued.

This will identify a state machine that is queued and ready to be started.

Priority is given to MT-LR because whilst another machine is cancelling

an MT-LR emergency request may be briefly queued.

@param aQueuedMachine A reference to a pointer that identifies a queued

	state machine. This pointer is set to NULL if there is no queued machine.

*/

void CProtocolManager::GetQueuedStateMachine(CStateMachineBase*& aQueuedMachine) const

	{

	if (iMtLr->IsMachineQueued())

		{

		aQueuedMachine = iMtLr;

		}

	else if (iMoLr->IsMachineQueued())

		{

		aQueuedMachine = iMoLr;

		}

	else if (iX3p->IsMachineQueued())

		{

		aQueuedMachine = iX3p;

		}

	else if (iNetLoc->IsMachineQueued())

		{

		aQueuedMachine = iNetLoc;

		}

	else

		{

		aQueuedMachine = NULL;

		}

	}

/** Resolve the conflict between an active procedure and a new request.

@param aNewOp The type of operation that is represented by the new request.

@param aNewPriority The priority of the new request - optional.

@return TBool An indication if the 

*/

CConfigManager::TConflictResult CProtocolManager::ResolveConflict(

			CConfigManager::TConflictOp aNewOp, 

			CConfigManager::TConflictPriority aNewPriority)

	{

	CConfigManager::TConflictResult conflictResult = CConfigManager::EConflictNone;

	CStateMachineBase* activeMachine;

	CStateMachineBase* cancellingMachine;

	GetActiveStateMachine(activeMachine);

	GetCancellingStateMachine(cancellingMachine);

	LBSLOG3(ELogP2, "CProtocolManager::ResolveConflict() Current op = %d, New op = %d\n", iCurrentOp.iOperation, aNewOp);

	// One special case relates to an existing MT-LR that is awaiting the 

	// measurement control after a privacy reject. This MT-LR sequence can be

	// cancelled once a new request arrives.

	if ((iMtLr == activeMachine) && (iMtLr->IsRejectedWaitingMeasureControl()))

		{

		iMtLr->CancelMachine(CStateMachineBase::ECancelNone);

		conflictResult = CConfigManager::EConflictCancelCurrent;

		}

	// There is an operation already in the process of being cancelled, 

	// so queue the new request until this completes.

	else if (NULL != cancellingMachine)

		{

		LBSLOG(ELogP2, "CProtocolManager::ResolveConflict() Queing new request while previous op cancelled\n");

		conflictResult = CConfigManager::EConflictQueueNew;

		}

	else

		{

		CConfigManager::TConflictOperation newOp;

		newOp.iOperation = aNewOp;

		newOp.iPriority = aNewPriority;

		// A special case is when tracking is set on and it is not a new MO-LR request.

		// If there is not a current active operation, or MOLR is active, then

		// there may be a need to cancel a tracking 'session'.

		if ((iLbsStatus & CLbsNetworkProtocolBase::ESystemStatusClientTracking) &&

			(CConfigManager::EOpMoLr != aNewOp) &&

			((NULL == activeMachine) || (iMoLr == activeMachine)))

			{

			// Use a fake MO-LR to obtain a conflict decision.

			CConfigManager::TConflictOperation fakeMoLrOp;

			fakeMoLrOp.iOperation = CConfigManager::EOpMoLr;

			fakeMoLrOp.iPriority = CConfigManager::EPriorityNone;

			conflictResult = iConfig->ConflictDecision(fakeMoLrOp, newOp);

			// Should tracking be cancelled?

			if ((CConfigManager::EConflictCancelCurrent == conflictResult) ||

				(CConfigManager::EConflictQueueCurrent == conflictResult))

				{

				// Turn tracking off

				iLbsStatus = CLbsNetworkProtocolBase::ESystemStatusNone;

				if (NULL == activeMachine)

					{

					// Cancel tracking session if we have no active operation and

					// there has been a preceding MOLR session

					if ((iMoLr->SessionId().SessionOwner().iUid != 0) ||

						(iMoLr->SessionId().SessionNum() != 0))

						{

						Gateway()->SessionCompleteInd(iMoLr->SessionId(), KErrPositionHighPriorityReceive);

						}

					conflictResult = CConfigManager::EConflictNone;

					}

				}

			}

		// If we have an active operation which needs a conflict decision

		else if( (NULL != activeMachine) /*&& (iCurrentOp.iOperation != CConfigManager::EOpNone)*/)

			{

			conflictResult = iConfig->ConflictDecision(iCurrentOp, newOp);

			}

		else

			{

			// no tracking and no active operation = no conflict

			}

		// Perform any initial action arising from conflict decision

		switch (conflictResult)

			{

		// Current operation must be cancelled

		case CConfigManager::EConflictCancelCurrent:

			// Indicate if the source of cancellation is the network or LBS

			if ((CConfigManager::EOpMtLr == aNewOp) || 

				(CConfigManager::EOpNiLr == aNewOp))

				{

				LBSLOG(ELogP2, "CProtocolManager::ResolveConflict() Cancelling state machine, client\n");

				activeMachine->CancelMachine(CStateMachineBase::ECancelNetworkCancel, KErrPositionHighPriorityReceive);

				}

			else

				{

				LBSLOG(ELogP2, "CProtocolManager::ResolveConflict() Cancelling state machine, network\n");

				activeMachine->CancelMachine(CStateMachineBase::ECancelClientCancel, KErrPositionHighPriorityReceive);

				}

			break;

		// Queue the current operation before performing new operation

		// Note: At present we only have a requirement to queue an X3P timer

		//       and the functionality to support this is as follows:

		//       (a) cancel current operation BUT without cancelling LBS session

		//       (b) silently consume any LBS responses that relate to this session

		//       (c) proceed with the new operation

		//       (d) wait for LBS (NRH) to repeat the X3P timer request

		case CConfigManager::EConflictQueueCurrent:

			activeMachine->CancelMachine(CStateMachineBase::ECancelClientCancelSilent, KErrPositionHighPriorityReceive);

			break;

		// Other conflict results require no further action here

		default:

			break;

			};

		}

	LBSLOG2(ELogP2, "CProtocolManager::ResolveConflict() returning conflict result %d\n", conflictResult);

	return conflictResult;

	}

/** Handle LBS request for Assistance Data

@param aDataRequestMask A mask identifying the set of data requested.

*/

void CProtocolManager::AssistanceDataReq(TLbsAsistanceDataGroup aDataRequestMask)

	{

	// Pass request to the assistance data manager to process

	TBool noAssistanceNeeded = iAssistMgr->ProcessDataRequest(aDataRequestMask);

	// No assistance needed?

	if (noAssistanceNeeded)

		{

		// Do nothing!

		}

	// Check if the requested data mask was entirely invalid

	else if (iAssistMgr->RequestErrorMask() == aDataRequestMask)

		{

		// Report the request error now

		DoAssistanceDataActions();

		}

	else

		{

		// Check if we have an active state machine

		CStateMachineBase* activeMachine;

		GetActiveStateMachine(activeMachine);

		if (NULL != activeMachine)

			{

			// Advise state machine of assistance data request

			activeMachine->AssistanceDataReq();

			}

		else

			{

			// Store assistance data error

			iAssistMgr->Error(KErrGeneral);

			// Report the error

			DoAssistanceDataActions();

			}

		}

	}

/** Handle LBS request for self locate

@param aSessionId The session ID supplied by LBS.

@param aDataRequestMask A mask identifying the set of data requested.

*/

void CProtocolManager::SelfLocationReq(const TLbsNetSessionId& aSessionId, 

				const TLbsNetPosRequestOptionsBase& aOptions)

	{

	LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq()\n");	

	const TLbsNetPosRequestOptionsAssistance options = reinterpret_cast<const TLbsNetPosRequestOptionsAssistance&> (aOptions);

	// Pass assistance data mask to the assistance data manager to process

	TBool noAssistanceNeeded = iAssistMgr->ProcessDataRequest(options.DataRequestMask());

	// Was assistance data request entirely invalid

	if (iAssistMgr->RequestErrorMask() == options.DataRequestMask() &&

		!noAssistanceNeeded)

		{

		// Ensure this error is reported

		DoAssistanceDataActions();

		noAssistanceNeeded = ETrue;

		}

	// Is there already an MO-LR active?

	if (CStateMachineBase::EStateActive == iMoLr->State())

		{

		LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq() Previously we would've ignored this request!!!!!!\n");

		}

	CConfigManager::TConflictResult conflictResult = ResolveConflict(CConfigManager::EOpMoLr);

	// Resolve any conflicts arising

	switch (conflictResult)

		{

	// Start MO-LR

	case CConfigManager::EConflictNone:

		LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq() No conflict\n");

		// Network interaction is not required under these circumstances:

		// (a) GPS mode is autonomous OR

		// (b) this is an old client AND no assistance data was requested

		if (TPositionModuleInfo::ETechnologyTerminal == options.PosMode() ||

			(!options.NewClientConnected() && noAssistanceNeeded))

			{

			// End the LBS session

			LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq() Ending session due to autonomous OR old client not requiring ass data\n");

			Gateway()->SessionCompleteInd(aSessionId, KErrNone);

			}

		else

			{

			// Status update sent to LBS

			StatusUpdate(CConfigManager::EOpMoLr, ETrue); // ETrue=new operation

			// Need to set the assistance data manager as if no data

			// has been received yet, and all previous data has been reported,

			// to ensure that any existing set of data is reported to LBS.

			iAssistMgr->DataReported();

			iAssistMgr->SetDataNotReceived();

			iMoLr->MoLrReq(aSessionId);

			LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq() CurrentOp --> EOpMoLr\n");

			iCurrentOp.iOperation = CConfigManager::EOpMoLr;

			iCurrentOp.iPriority = CConfigManager::EPriorityNone;

			}

		break;

	// Reject the new request

	case CConfigManager::EConflictRejectNew:

		LBSLOG(ELogP2, "CProtocolManager::SelfLocationReq() Conflict: Rejecting new request\n");

		Gateway()->SessionCompleteInd(aSessionId, KErrServerBusy);

		break;

	// New request is queued whilst current operation continues

	// or current operation is being cancelled.

	case CConfigManager::EConflictQueueNew:

	case CConfigManager::EConflictCancelCurrent:

	case CConfigManager::EConflictQueueCurrent:

		LBSLOG2(ELogP2, "CProtocolManager::SelfLocationReq() Conflict %d: Queueing new request\n", conflictResult);

		iMoLr->QueueMoLrReq(aSessionId);

		break;

	default:

		break;

		};

	}

/** Handle LBS completion of self locate

@param aSessionId The session to be completed.

@param aReason Completion reason value.

*/

void CProtocolManager::SelfLocationCompleteInd(const TLbsNetSessionId& aSessionId, 

				TInt aReason)

	{

	// Check we have an active self locate and valid session ID,

	// otherwise silently consume this completion indication.

	if ((CStateMachineBase::EStateActive == iMoLr->State()) &&

		(aSessionId == iMoLr->SessionId()))

		{

		iMoLr->CancelMachine(CStateMachineBase::ECancelClientCancel, aReason);

		}

	}

/** Handle LBS system status indication

@param aStatus The status indication from LBS.

*/

void CProtocolManager::SystemStatusInd(CLbsNetworkProtocolBase::TLbsSystemStatus aStatus)

	{

	iLbsStatus = aStatus;

	}

/** Handle LBS Location Response

@param aSessionId The session ID for which this response is provided.

@param aReason An error response; KErrNone if position is okay.

@param aPosInfo The location response information

*/

void CProtocolManager::LocationResp(const TLbsNetSessionId& aSessionId, TInt aReason, const TPositionInfoBase& aPosInfo)

	{

	// Check we have an active state machine to handle this

	CStateMachineBase* activeMachine;

	GetActiveStateMachine(activeMachine);

	// Special requirement to allow MT-LR to receive late responses

	if ((NULL == activeMachine) && 

		(CStateMachineBase::EStateCancelling == iMtLr->State()))

		{

		activeMachine = iMtLr;

		}

	// Check there is an active state machine and that session ID is legitimate,

	// otherwise silently consume this location response.

	if ((NULL != activeMachine) && (aSessionId == activeMachine->SessionId()))

		{

		activeMachine->LocationResp(aReason, aPosInfo);

		}

	}

/** Handle LBS Privacy Response

@param aResponse Privacy response value.

*/

void CProtocolManager::PrivacyResp(const TLbsNetSessionId& aSessionId, 

			const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResponse)

	{

	// Check we have an active MT-LR state machine and valid session ID,

	// otherwise silently consume this privacy response.

	if ((CStateMachineBase::EStateActive == iMtLr->State()) &&

		(aSessionId == iMtLr->SessionId()))

		{

		iMtLr->PrivacyResp(aResponse);

		}

	}

/** Handle LBS Network Based Location Request

*/

void CProtocolManager::NetworkBasedLocationReq(const TLbsNetSessionId& aSessionId, 

					const TLbsNetPosRequestOptionsBase& /*aOptions*/)

	{

	LBSLOG2(ELogP2, "CProtocolManager::NetworkBasedLocationReq() session id %d\n", aSessionId.SessionNum());

	// Resolve any conflicts arising