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

// the MT-LR protocol state machine.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include "cmtlrstatemachine.h"

#include "cmtlrstatehandler.h"

#include <e32property.h>

#include <lbs/test/lbsnetsimstatus.h>

/** KMtLrReqIssuedTimerEvent

Identity of timer for when MT-LR request issued by network

*/

const TInt KMtLrReqIssuedTimerEvent = 0x10;

/** KMtLrReqIssuedTimerDurationInSec

Timer duration for when MT-LR request issued by network

*/

const TInt KMtLrReqIssuedTimerDurationInSec = 30;

/** KMeasureControlTimerEvent

Identity of timer for when measurement control expected by LBS

*/

const TInt KMeasureControlTimerEvent = 0x20;

/** KMeasureControlTimerDurationInSec

Timer duration for when measurement control expected by LBS

*/

const TInt KMeasureControlTimerDurationInSec = 20;

/** KLocRespTimerEvent

Identity of timer for when location response expected by network

*/

const TInt KLocRespTimerEvent = 0x30;

/** KLocRespTimerDurationInSec

Timer duration for when location response expected by network

*/

const TInt KLocRespTimerDurationInSec = 64;

/** KMaxQueueEntry

Maximum entries in this state machine request queue.

*/

const TInt KMaxQueueEntry = 5;

/** Static constructor.

@param aObserver Reference to state machine observer.

@return A new instance of the CMtLrStateMachine class

*/  

CMtLrStateMachine* CMtLrStateMachine::NewL(MStateMachineObserver& aObserver)

	{

	CMtLrStateMachine* self = new (ELeave) CMtLrStateMachine(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/** Standard constructor.

@param aObserver Reference to state machine observer.

*/  

CMtLrStateMachine::CMtLrStateMachine(MStateMachineObserver& aObserver)

: CStateMachineBase(aObserver)

	{

	}

/** Standard destructor.

*/  

CMtLrStateMachine::~CMtLrStateMachine()

	{

	delete iLocRespTimer;

	delete iMeasureControlTimer;

	delete iMtLrReqIssuedTimer;

	}

/** Private second-stage constructor.

*/  

void CMtLrStateMachine::ConstructL()

	{

	CActiveScheduler::Add(this);

	// Create state handler

	iStateHandler = CMtLrStateHandler::NewL(*this);

	// Create timers used during MT-LR protocol procedure

	iMtLrReqIssuedTimer = CLbsCallbackTimer::NewL(*this);

	iMeasureControlTimer = CLbsCallbackTimer::NewL(*this);

	iLocRespTimer = CLbsCallbackTimer::NewL(*this);

	iAssistDataTimer = CLbsCallbackTimer::NewL(*this);

	// Create request queue

	iQueue = CStateQueue::NewL(KMaxQueueEntry);

	}

/** Retrieve current MT-LR State

@return TMtLrState Current MT-LR state

*/

CMtLrStateMachine::TMtLrState CMtLrStateMachine::CurrentState()

	{

	return iCurrentState;

	}

/** Start MT-LR request timer

This is called when an MT-LR request is received from the network

and it requires a response before the timer expires.

*/

void CMtLrStateMachine::StartMtLrReqTimer()

	{

	if(iMtLrReqIssuedTimer->IsActive())

		{

		iMtLrReqIssuedTimer->Cancel();

		}

	iMtLrReqIssuedTimer->EventAfter(TTimeIntervalSeconds(KMtLrReqIssuedTimerDurationInSec), KMtLrReqIssuedTimerEvent);

	}

/** Start Measure Control timer

This is called when Measurement Control is expected by LBS.

*/

void CMtLrStateMachine::StartMeasureControlTimer()

	{

	if(iMeasureControlTimer->IsActive())

		{

		iMeasureControlTimer->Cancel();

		}

	iMeasureControlTimer->EventAfter(TTimeIntervalSeconds(KMeasureControlTimerDurationInSec), KMeasureControlTimerEvent);

	}

/** Start location response timer

The state handler calls this when it has sent a location request

to the client and requires a response before the timer expires.

*/

void CMtLrStateMachine::StartLocRespTimer()

	{

	if(iLocRespTimer->IsActive())

		{

		iLocRespTimer->Cancel();

		}

	iLocRespTimer->EventAfter(TTimeIntervalSeconds(KLocRespTimerDurationInSec), KLocRespTimerEvent);

	}

/** Privacy requestor information

This is called by state handlers to retrieve the most

recent privacy request info.

@return TLbsExternalRequestInfo Currently held privacy requestor information

*/

const TLbsExternalRequestInfo& CMtLrStateMachine::PrivacyReqInfo() const

	{

	return iPrivacyReqInfo;

	}

/** Privacy request

This is called by state handlers to retrieve the most

recent privacy request.

@return const TLbsNetPosRequestPrivacy& Currently held privacy request

*/

const TLbsNetPosRequestPrivacy& CMtLrStateMachine::PrivacyReq() const

	{

	return iPrivacyRequest;

	}

/** Privacy response value

This is called by state handlers to retrieve the most

recent privacy response.

@return TLbsPrivacyResponse Currently held privacy response value

*/

const CLbsNetworkProtocolBase::TLbsPrivacyResponse& CMtLrStateMachine::PrivacyResponseValue() const

	{

	return iPrivacyResp;

	}

/** Has privacy response been handled.

This is called to determine if privacy response handled.

@return TBool ETrue if privacy response handled

*/

TBool CMtLrStateMachine::IsPrivacyResponseHandled() const

	{

	return iPrivacyResponseHandled;

	}

/** Has privacy response been handled.

This is called to determine if privacy response handled.

@return TBool ETrue if privacy response handled

*/

TBool CMtLrStateMachine::IsRejectedWaitingMeasureControl() const

	{

	return (EStateClientSessToCloseWaitMeasure == iCurrentState);

	}

/** Is this an emergency situation.

This is called to determine if there is an emergency situation for which

an MT-LR is being requested.

@return TBool ETrue if emergency situation exists

*/

TBool CMtLrStateMachine::IsEmergency() const

	{

#pragma message("Emergency timers not implemented.")

	// Retrieve current value of emergency property published by NetSim

	TBool stateValue = EFalse;

	RProperty::Get(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, stateValue);

	return stateValue;

	}

/** Initialise internal state attributes.

This is used when new MT-LR procedure commences.

*/

void CMtLrStateMachine::InitialiseProcedure()

	{

	// Initialise state machine

	InitialiseMachineBase();

	iPrivacyResponseRecvd = EFalse;

	iPrivacyResponseHandled = EFalse;

	ASSERT(iStateHandler != NULL);

	iStateHandler->Initialise();

	}

/** Procedure is done.

*/  

void CMtLrStateMachine::ProcedureDone()

	{

	// If a location response error has been reported then forward it to network

	if (KErrNone != LocRespReason())

		{

		CNetworkInterface::TNetworkError netError = 

						Observer().Network()->LocationResp(LocRespReason());

		// Handle network-related error

		if (CNetworkInterface::ENone != netError)

			{

			Observer().NetworkErrorReported();

			}

		}

	// Procedure is complete

	CompleteProcedure();

	}

/** Prepare state transition.

*/  

void CMtLrStateMachine::PreStateTransition()

	{

	}

/** State transition.

This method determines the next state to be adopted by the state machine.

*/

void CMtLrStateMachine::StateTransition()

	{

	if (CancelPending())

		{

		SetMachineAsCancelling();

		iCurrentState = EStateCancelling;

		}

	else

		{

		// Set new state		

		switch (iCurrentState)

			{

		case EStateNull:

			iCurrentState = EStateNetReqRecvd;

			break;

		case EStateNetReqRecvd:

			iCurrentState = EStatePrivacySessStarted;

			iIsPrivacyRespBeforeMeasureControl = EFalse;

			break;

		case EStatePrivacySessStarted:

			// Location request received?

			if (iIsLocReqReceived)

				{

				iCurrentState = EStateMeasureDataRecvd;

				}

			// Privacy response received?

			else if (iPrivacyResponseRecvd)

				{

				iIsPrivacyRespBeforeMeasureControl = ETrue;

				iPrivacyResponseHandled = ETrue;

				iCurrentState = EStatePrivacyRespRecvd;

				// Start timer for when the measurement control is expected

				StartMeasureControlTimer();

				}

			break;

		case EStatePrivacyRespRecvd:

			// Privacy not accepted?

			if (CLbsNetworkProtocolBase::EPrivacyResponseAccepted != iPrivacyResp)

				{

				iCurrentState = EStatePrivacyReject;

				}

			else

				{

				iCurrentState = EStateMeasureDataRecvd;

				}

			break;

		case EStatePrivacyRespRecvdAfterMeasure:

			// Privacy not accepted?

			if (CLbsNetworkProtocolBase::EPrivacyResponseAccepted != iPrivacyResp)

				{

				iCurrentState = EStatePrivacyRejectAfterMeasure;

				}

			else

				{

				iCurrentState = EStateLocRespRecvd;

				}

			break;

		case EStatePrivacyReject:

			iCurrentState = EStateClientSessToCloseWaitMeasure;

			break;

		case EStatePrivacyRejectAfterMeasure:

			iCurrentState = EStateLocRespRecvd;

			break;

		case EStateMeasureDataRecvd:

			iCurrentState = EStateNetBasedLocSent;

			break;

		case EStateNetBasedLocSent:

			iIsMeasureControlHandled = ETrue;

			// Was privacy already rejected

			if (iIsPrivacyRespBeforeMeasureControl &&

				CLbsNetworkProtocolBase::EPrivacyResponseAccepted != iPrivacyResp)

				{

				ProcedureDone();

				}

			else

				{

				iCurrentState = EStateLocReqByNet;

				}

			break;

		case EStateLocReqByNet:

			iCurrentState = iIsPrivacyRespBeforeMeasureControl ? 

							EStateLocRespRecvd : EStatePrivacyRespRecvdAfterMeasure;

			break;

		case EStateLocRespRecvd:

			iCurrentState = EStateLocSentToNet;

			break;

		case EStateLocSentToNet:

			iCurrentState = EStateClientSessToCloseAfterMeasure;

			break;

		case EStateClientSessToCloseWaitMeasure:

			iCurrentState = EStateMeasureDataRecvd;

			break;

		case EStateClientSessToCloseWaitLocResp:

			// We are waiting for location response from LBS after the

			// preceding session closes. Check to see if we have timeout

			// otherwise we must have received the response.

			if (Cancelling() && (KErrTimedOut == iLocRespReason))

				{

				iCurrentState = EStateCancelling;

				}

			else

				{

				ProcedureDone();

				}

			break;

		case EStateClientSessToCloseAfterMeasure:

			ProcedureDone();

			break;

		case EStateSessionsClosed:

			// Procedure has completed

			CompleteProcedure();

			break;

		case EStateCancelling:

			switch (iCancelSource)

				{

			case ECancelNone:

			case ECancelClosing:

			case ECancelClientCancel:

			case ECancelClientCancelSilent:

				CompleteProcedure();

				break;

			case ECancelNetworkError:

				iCurrentState = EStateClientSessToCloseAfterMeasure;

				break;

			case ECancelNetworkTimeout:

				// We were waiting for measurement control.

				// Was privacy rejected?

				if (CLbsNetworkProtocolBase::EPrivacyResponseAccepted != iPrivacyResp)

					{

					ProcedureDone();

					}

				else

					{

					iCurrentState = EStateClientSessToCloseAfterMeasure;

					}

				break;

			case ECancelClientTimeout:

				// We were either waiting for a location response or a privacy response

				// Privacy response will timeout first, but we may need to still wait for

				// a location response.

				if (!iPrivacyResponseRecvd && iIsMeasureControlHandled && 

					(KErrTimedOut != iLocRespReason))

					{

					iCurrentState = EStateClientSessToCloseWaitLocResp;

					}

				else

					{

					iCurrentState = EStateClientSessToCloseAfterMeasure;

					}

				break;

			case ECancelNetworkCancel:

				iCurrentState = EStateClientSessToCloseAfterMeasure;

				break;

			default:

				User::Panic(KProtocolModulePanic, EProtocolModuleCancelSource);

				break;

				};

			break;

		default:

			User::Panic(KProtocolModulePanic, EProtocolModuleMtLrState);

			break;

			};

		}

	}

/** Complete the procedure.

*/  

void CMtLrStateMachine::CompleteProcedure()

	{

	iCurrentState = EStateNull;

	// Complete state machine

	CompleteMachineBase();

	}

/** Complete state transition.

This is called by the base class when a state transition has

concluded and it provides an opportunity for the state machine 

to perform actions required immediately after this transition.

The method can also initiate a further change of state. This is

relevant when the state machine is required to perform an autonomous

transition from one state to another e.g. this occurs when several

interactions are required arising from a single external trigger.

*/  

void CMtLrStateMachine::PostStateTransition()

	{

	// Some states are transitory i.e. they require

	// an automatic transition to the next state

	if ( CancelPending() ||

		 (EStateNetReqRecvd == iCurrentState) ||

	 	 ((CLbsNetworkProtocolBase::EPrivacyResponseAccepted != PrivacyResponseValue()) &&

		  ((EStatePrivacyRespRecvd == iCurrentState) || (EStatePrivacyRespRecvdAfterMeasure == iCurrentState))) ||

	 	 (EStatePrivacyReject == iCurrentState) ||

	 	 (EStateMeasureDataRecvd == iCurrentState) ||

	 	 (EStateNetBasedLocSent == iCurrentState) ||

	 	 (EStateLocRespRecvd == iCurrentState) ||

	 	 (EStateLocSentToNet == iCurrentState) ||

	 	 (EStateClientSessToCloseAfterMeasure == iCurrentState) ||

	 	 (EStateSessionsClosed == iCurrentState) ||

	 	 (EStateCancelling == iCurrentState)

	   )

		{

		// Perform a state transition

		PerformStateTransition();

		}

	}

/** Do actions required for a queued request.

This currently only initiates another state change but it 

has the scope for further actions to be carried out according

to the nature of a queued request.

*/

void CMtLrStateMachine::DoQueuedRequest(TInt aRequest)

	{

	switch (aRequest)

		{

	case EQueuePrivacyResponse:

	case EQueueLocResponse:

	case EQueueMeasurementControl: