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

// protocol state machines used in the Test Protocol Module.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include "cstatemachinebase.h"

#include "cstatehandlerbase.h"

#include "lbsdevloggermacros.h"

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

// State Machine Base Class

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

/** Standard constructor.

@param aObserver A reference to the state machine observer. 

*/  

CStateMachineBase::CStateMachineBase(MStateMachineObserver& aObserver)

: CActive(EPriorityLow), iObserver(aObserver), iProtocolState(EStateReady)

	{

	ResetSessionId();

	}

/** Standard destructor.

*/  

CStateMachineBase::~CStateMachineBase()

	{

	iCancelSource = ECancelClosing;

	Cancel();

	delete iAssistDataTimer;

	delete iQueue;

	delete iStateHandler;

	}

/** Retrieve reference to state machine observer.

@return MStateMachineObserver A reference to the observer. 

*/  

MStateMachineObserver& CStateMachineBase::Observer()

	{

	return iObserver;

	}

/** Set session ID

@param aSessionId Identifier to be used by the state machine whenever

	the session ID is to be used.

*/

void CStateMachineBase::SessionId(const TLbsNetSessionId& aSessionId)

	{

	iSessionId = aSessionId;

	}

/** Reset session ID

*/

void CStateMachineBase::ResetSessionId()

	{

	iSessionId.SetSessionOwner(TUid::Uid(0));

	iSessionId.SetSessionNum(0);

	}

/** Get session ID

@return const TLbsNetSessionId& The session ID currently used by the state machine.

*/

const TLbsNetSessionId& CStateMachineBase::SessionId() const

	{

	return iSessionId;

	}

/** Set ID for queued session

@param aSessionId Identifier to be used for a queued session.

*/

void CStateMachineBase::QueueSessionId(const TLbsNetSessionId& aSessionId)

	{

	iQueueSessionId = aSessionId;

	}

/** Get ID of queued session

@return const TLbsNetSessionId& The session ID of the queued session

*/

const TLbsNetSessionId& CStateMachineBase::QueueSessionId() const

	{

	return iQueueSessionId;

	}

/** Retrieve current general protocol state.

@return CStateMachineBase::TProtocolState The current general 

	protocol state for this state machine.

@see CStateMachineBase::TProtocolState

*/  

CStateMachineBase::TProtocolState CStateMachineBase::State() const

	{

	return iProtocolState;

	}

/** Start additional assistance data timer.

The state machine calls this when it has issued a request for additional

assistance data from the network.

*/

void CStateMachineBase::StartAssistDataTimer()

	{

	if (iAssistDataTimer->IsActive())

		{

		iAssistDataTimer->Cancel();

		}

	iAssistDataTimer->EventAfter(TTimeIntervalSeconds(KAssistDataTimerDurationInSec), KAssistDataTimerEvent);

	}

/** Indicates if location request has been received.

@return TBool ETrue if location request has been received.

*/  

TBool CStateMachineBase::IsLocReqReceived() const

	{

	return iIsLocReqReceived;

	}

/** Indicates if location response has been sent to network.

@return TBool ETrue if location response has been sent.

*/ 

TBool CStateMachineBase::IsLocRespSent() const

	{

	return iIsLocRespSent;

	}

/** Indicates if Measurement Control has been handled.

@return TBool ETrue if Measurement Control has been handled.

*/  

TBool CStateMachineBase::IsMeasureControlHandled() const

	{

	return iIsMeasureControlHandled;

	}

/** Indicates if assistance data action is required.

@return TBool ETrue if assistance data action is required.

*/  

TBool CStateMachineBase::IsAssistanceDataActionReq() const

	{

	return iAssistanceDataActionRequired;

	}

/** Client close reason.

This is called by state handlers to determine what reason to

provide to the client for the client session closing.

@return TInt Reason value.

*/

TInt CStateMachineBase::ClientCloseReason()  const

	{

	TInt reason = KErrNone;

	if (KErrPositionHighPriorityReceive == iClientCancelReason)

		{

		reason = iClientCancelReason;

		}

	else if (KErrNone == iNetworkCancelReason)

		{

		switch (iCancelSource)

			{

		case ECancelNetworkCancel:

			reason = KErrCancel;

			break;

		case ECancelNetworkError:

			reason = KErrDisconnected;

			break;

		case ECancelClientTimeout:

		case ECancelNetworkTimeout:

			reason = KErrTimedOut;

			break;

		case ECancelNone:

			{

			// The reson returned from here is used for teht Session Complete Message from the 

			// Network Gateway to the NRH, so use the value which was received with the location

			// response

			reason = LocRespReason();

			if(reason == KErrCancel || reason == KErrPermissionDenied)

				{

				reason = KErrNone;

				}

			}

			break;

		case ECancelClientCancel:

			reason = iClientCancelReason;

			break;

		case ECancelClientCancelSilent:

		case ECancelClosing:

			break;

		default:

			User::Panic(KProtocolModulePanic, EProtocolModuleCancelSource);

			break;

			};

		}

	else

		{

		reason = iNetworkCancelReason;

		}

	return reason;

	}

/** Network close reason.

This is called by state handlers to determine what reason to

provide to the network for the network session closing.

@return TInt Reason value.

*/

TInt CStateMachineBase::NetworkCloseReason() const

	{

	TInt reason = KErrNone;

	if (KErrPositionHighPriorityReceive == iNetworkCancelReason)

		{

		reason = iNetworkCancelReason;

		}

	else if (KErrNone == iClientCancelReason)

		{

		switch (iCancelSource)

			{

		case ECancelClientCancel:

		case ECancelClientCancelSilent:

			reason = KErrCancel;

			break;

		case ECancelClientTimeout:

		case ECancelNetworkTimeout:

			reason = KErrTimedOut;

			break;

		case ECancelNone:

		case ECancelNetworkCancel:

		case ECancelNetworkError:

		case ECancelClosing:

			break;

		default:

			User::Panic(KProtocolModulePanic, EProtocolModuleCancelSource);

			break;

			};

		}

	else

		{

		reason = iClientCancelReason;

		}

	return reason;

	}

/** Silent cancellation of LBS client is taking place.

This is called by state handlers to determine if there is a silent cancellation

of the LBS client session taking place, which means that LBS does not receive

any cancel-related messages for this session.

@return TBool A value of ETrue indicates silent client cancellation is taking place.

*/

TBool CStateMachineBase::IsSilentClientCancel() const

	{

	return (ECancelClientCancelSilent == iCancelSource);

	}

/** Network connection error indication.

This is called by state handlers to determine if a network connection error

has been experienced. In this situation the state handlers should not attempt

to send responses to the network.

@return TBool A value of ETrue indicates a network connection error exists.

*/

TBool CStateMachineBase::IsNetworkConnectionError() const

	{

	return ((EStateCancelling == iProtocolState) && (ECancelNetworkError == iCancelSource));

	}

/** Location request type.

This is called by state handlers to determine what type of location

request is to be specified to LBS. This is usually fixed for a given

state machine, but there is scope to support more than type of request

within a single state machine.

@return MLbsNetworkProtocolObserver::TLbsNetProtocolService request type.

*/

MLbsNetworkProtocolObserver::TLbsNetProtocolService CStateMachineBase::LocReqType() const

	{

	return iLocReqType;

	}

/** Location response reason.

This is called by state handlers to determine what reason to

provide to the network for the location response failure.

@return TInt Reason value.

*/

TInt CStateMachineBase::LocRespReason() const

	{

	TInt reason = KErrNone;

	// Was a Location response error provided?

	if (KErrNone != iLocRespReason)

		{

		reason = iLocRespReason;

		}

	// Are we cancelling?

	else if (Cancelling())

		{

		switch (iCancelSource)

			{

		case ECancelClientCancel:

		case ECancelClientCancelSilent:

			if (KErrPositionHighPriorityReceive == iClientCancelReason)

				{

				reason = iClientCancelReason;

				}

			else

				{

				reason = KErrCancel;

				}

			break;

		case ECancelClientTimeout:

			reason = KErrGeneral;

			break;

		case ECancelNone:

		case ECancelNetworkError:

		case ECancelNetworkTimeout:

		case ECancelNetworkCancel:

		case ECancelClosing:

			break;

		default:

			User::Panic(KProtocolModulePanic, EProtocolModuleCancelSource);

			break;

			};

		}

	return reason;

	}

/** Location response position.

This is called by state handlers to retrieve the most

recent reported position.

@return TPositionInfoBase Currently held location response position

*/

const TPositionInfoBase& CStateMachineBase::LocRespPosition() const

	{

	return iLocRespPosInfo;

	}

/** Reference Location.

This is called by state handlers to retrieve the most

recent reported reference location.

@return TPositionInfoBase Currently held reference position

*/

const TPositionInfoBase& CStateMachineBase::ReferenceLoc() const

	{

	return iReferenceLoc;

	}

/** Location request quality.

This is called by state handlers to retrieve the most

recent location request quality.

@return TLbsNetPosRequestQuality Currently held location request quality

*/ 

const TLbsNetPosRequestQuality& CStateMachineBase::LocReqQuality() const

	{

	return iLocReqQuality;

	}

/** Location request positioning method.

This is called by state handlers to retrieve the most

recent location request positioning method.

@return TLbsNetPosRequestMethod Currently held location request positioning method

*/ 

const TLbsNetPosRequestMethod& CStateMachineBase::PosMethod() const

	{

	return iPosMethod;

	}

/** Initialise internal state machine attributes.

This is used when a new protocol procedure commences.

*/

void CStateMachineBase::InitialiseMachineBase()

	{

	iTransitionState = ETransitionNull;

	iIsCancelPending = EFalse;

	iCancelSource = ECancelNone;

	iClientCancelReason = KErrNone;

	iNetworkCancelReason = KErrNone;

	iIsLocReqReceived = EFalse;

	iIsLocRespSent = EFalse;

	iIsMeasureControlHandled = EFalse;

	iIsAdditionalDataExpected = EFalse;

	iAssistanceDataActionRequired = EFalse;

	iLocRespReason = KErrNone;

	LBSLOG(ELogP2, "CStateMachineBase::InitialiseMachineBase() protocol state ---> EStateActive \n");

	iProtocolState = EStateActive;

	iIsMachineQueued = EFalse;

	}

/** Complete state machine attributes.

This is used when a protocol procedure completes.

*/

void CStateMachineBase::CompleteMachineBase()

	{

	LBSLOG(ELogP2, "CStateMachineBase::CompleteMachineBase() protocol state ---> EStateReady\n");

	iProtocolState = EStateReady;

	// Inform Protocol Manager that procedure is complete

	Observer().ProcedureCompleteInd();

	}

/** Store location response.

@param aPosInfo Location information response

*/

void CStateMachineBase::StoreLocationResp(TInt aReason, const TPositionInfoBase& aPosInfo)

	{

	iLocRespReason = aReason;

	iLocRespPosInfo = reinterpret_cast <const TPositionInfo&> (aPosInfo);

	}

/** Store network location cancel reason.

@param aReason The reason for cancelling network location

*/

void CStateMachineBase::StoreNetLocCancelReason(TInt aReason)

	{

	iNetLocCancelReason = aReason;

	}

/** Store location request quality

@param aQuality Location request quality

*/

void CStateMachineBase::StoreLocReqQuality(const TLbsNetPosRequestQuality& aQuality)

	{

	iLocReqQuality = aQuality;

	}

/** Store location request positioning method

@param aPosMethod Location request positioning method

*/

void CStateMachineBase::StorePosMethod(const TLbsNetPosRequestMethod& aPosMethod)

	{

	iPosMethod = aPosMethod;

	}

/** Store reference location

@param aPosInfo Network reference location information

*/

void CStateMachineBase::StoreRefLoc(const TPositionInfoBase& aPosInfo)

	{

	iReferenceLoc = reinterpret_cast <const TPositionInfo&> (aPosInfo);

	}

/** Enter new state.

This asks the state handler to perform the actions required when

entering a new state.

*/  

void CStateMachineBase::EnterNewState()

	{

	ASSERT(iStateHandler != NULL);

	// Perform entry actions for the new state

	iStateHandler->EntryActions();

	}

/** Exit current state.

This asks the state handler to perform the actions required when

exiting from a state.

*/  

void CStateMachineBase::ExitCurrentState()

	{

	ASSERT(iStateHandler != NULL);

	// Perform exit actions for the current state

	iStateHandler->ExitActions();

	}

/** Perform a state transition.

This initiates a state transition and performs the first stage of

this by exiting from the current state.

*/  

void CStateMachineBase::PerformStateTransition()

	{

	if (!IsActive())

		{

		iTransitionState = ETransitionExit;

		DoStateTransitionStage();

		}

	}