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

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include "cmtlrstatemachine.h"

#include "cmtlrstatehandler.h"

/** Static constructor.

@param aMachine A reference to the parent state machine.

@return A new instance of the CMtLrStateHandler class

*/  

CMtLrStateHandler* CMtLrStateHandler::NewL(CStateMachineBase& aMachine)

	{

	CMtLrStateHandler* self = new (ELeave) CMtLrStateHandler(aMachine);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/** Standard constructor.

@param aMachine A reference to the parent state machine.

*/  

CMtLrStateHandler::CMtLrStateHandler(CStateMachineBase& aMachine)

: CStateHandlerBase(aMachine)

	{

	}

/** Standard destructor.

*/  

CMtLrStateHandler::~CMtLrStateHandler()

	{

	}

/** Private second-stage constructor.

*/  

void CMtLrStateHandler::ConstructL()

	{

	}

/** Initialise state attributes

*/

void CMtLrStateHandler::Initialise()

	{

	}

/** Perform entry actions.

This is called from the state machine to perform any actions

associated with entering the current state.

*/  

void CMtLrStateHandler::EntryActions()

	{

	CNetworkInterface::TNetworkError netError = CNetworkInterface::ENone;

	// Retrieve current state and act accordingly

	CMtLrStateMachine& mtlrMachine = reinterpret_cast <CMtLrStateMachine&> (iMachine);

	switch(mtlrMachine.CurrentState())

		{

	case CMtLrStateMachine::EStateNull:

		// No action required

		break;

	case CMtLrStateMachine::EStateNetReqRecvd:

		// No action required

		break;

	case CMtLrStateMachine::EStatePrivacySessStarted:

		// Forward request to gateway

		mtlrMachine.Observer().Gateway()->PrivacyReq(

										mtlrMachine.SessionId(),

										mtlrMachine.IsEmergency(),

										mtlrMachine.PrivacyReq(),

										mtlrMachine.PrivacyReqInfo());

		break;

	case CMtLrStateMachine::EStatePrivacyRespRecvd:

		// Forward response to network

		mtlrMachine.Observer().Network()->MtLrResp(mtlrMachine.PrivacyResponseValue());

		break;

	case CMtLrStateMachine::EStatePrivacyRespRecvdAfterMeasure:

		// Forward response to network

		mtlrMachine.Observer().Network()->MtLrResp(mtlrMachine.PrivacyResponseValue());

		break;

	case CMtLrStateMachine::EStatePrivacyReject:

		// no action required

		break;

	case CMtLrStateMachine::EStatePrivacyRejectAfterMeasure:

		// no action required

		break;

	case CMtLrStateMachine::EStateMeasureDataRecvd:

		// No action required

		break;

	case CMtLrStateMachine::EStateNetBasedLocSent:

		// Send network location to gateway

		mtlrMachine.Observer().Gateway()->NetworkLocationInd(

							mtlrMachine.SessionId(),

							mtlrMachine.ReferenceLoc());

		break;

	case CMtLrStateMachine::EStateLocReqByNet:

		// Send location request to gateway

		mtlrMachine.Observer().Gateway()->LocationReq(

							mtlrMachine.SessionId(),

							mtlrMachine.IsEmergency(),

							mtlrMachine.LocReqType(),

							mtlrMachine.LocReqQuality(),

							mtlrMachine.PosMethod());

		// Start a timer for the anticipated response

		mtlrMachine.StartLocRespTimer();

		break;

	case CMtLrStateMachine::EStateLocRespRecvd:

		// No action required

		break;

	case CMtLrStateMachine::EStateLocSentToNet:

		// If a location response does not indicate an error then forward it to network

		if (KErrNone == mtlrMachine.LocRespReason())

			{

			netError = mtlrMachine.Observer().Network()->LocationResp(mtlrMachine.LocRespPosition());

			}

		break;

	case CMtLrStateMachine::EStateClientSessToCloseWaitMeasure:

		// Send session completion data to gateway

		mtlrMachine.Observer().Gateway()->SessionCompleteInd(mtlrMachine.SessionId(), 

															mtlrMachine.ClientCloseReason());

		break;

	case CMtLrStateMachine::EStateClientSessToCloseAfterMeasure:

		// Send session completion data to gateway

		mtlrMachine.Observer().Gateway()->SessionCompleteInd(mtlrMachine.SessionId(), 

															mtlrMachine.ClientCloseReason());

		break;

	case CMtLrStateMachine::EStateClientSessToCloseWaitLocResp:

		// Send session completion data to gateway

		mtlrMachine.Observer().Gateway()->SessionCompleteInd(mtlrMachine.SessionId(), 

															mtlrMachine.ClientCloseReason());

		break;

	case CMtLrStateMachine::EStateSessionsClosed:

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

		if (KErrNone != mtlrMachine.LocRespReason())

			{

			netError = mtlrMachine.Observer().Network()->LocationResp(mtlrMachine.LocRespReason());

			}

		break;

	case CMtLrStateMachine::EStateCancelling:

		// Is privacy response handled yet?

		if (!mtlrMachine.IsPrivacyResponseHandled())

			{

			mtlrMachine.Observer().Network()->MtLrResp(mtlrMachine.PrivacyResponseValue());

			}

		break;

	default:

		User::Panic(KProtocolModulePanic, EProtocolModuleMtLrState);

		break;

		}

	// Handle network-related error

	if (CNetworkInterface::ENone != netError)

		{

		mtlrMachine.Observer().NetworkErrorReported();

		}

	}

/** Perform exit actions.

This is called from the state machine to perform any actions

associated with exiting from the current state.

*/  

void CMtLrStateHandler::ExitActions()

	{

	CNetworkInterface::TNetworkError netError = CNetworkInterface::ENone;

	// Retrieve current state and act accordingly

	CMtLrStateMachine& mtlrMachine = reinterpret_cast <CMtLrStateMachine&> (iMachine);

	switch(mtlrMachine.CurrentState())

		{

	case CMtLrStateMachine::EStateNull:

		// no action required

		break;

	case CMtLrStateMachine::EStateNetReqRecvd:

		// no action required

		break;

	case CMtLrStateMachine::EStatePrivacySessStarted:

		break;

	case CMtLrStateMachine::EStatePrivacyRespRecvd:

		// no action required

		break;

	case CMtLrStateMachine::EStatePrivacyRespRecvdAfterMeasure:

		// no action required

		break;

	case CMtLrStateMachine::EStatePrivacyReject:

		// no action required

		break;

	case CMtLrStateMachine::EStatePrivacyRejectAfterMeasure:

		// no action required

		break;

	case CMtLrStateMachine::EStateMeasureDataRecvd:

		// no action required

		break;

	case CMtLrStateMachine::EStateNetBasedLocSent:

		// no action required

		break;

	case CMtLrStateMachine::EStateLocReqByNet:

		// no action required

		break;

	case CMtLrStateMachine::EStateLocRespRecvd:

		// no action required

		break;

	case CMtLrStateMachine::EStateLocSentToNet:

		// no action required

		break;

	case CMtLrStateMachine::EStateClientSessToCloseWaitMeasure:

		// no action required

		break;

	case CMtLrStateMachine::EStateClientSessToCloseAfterMeasure:

		// no action required

		break;

	case CMtLrStateMachine::EStateClientSessToCloseWaitLocResp:

		// no action required

		break;

	case CMtLrStateMachine::EStateSessionsClosed:

		// no action required

		break;

	case CMtLrStateMachine::EStateCancelling:

		// no action required

		break;

	default:

		User::Panic(KProtocolModulePanic, EProtocolModuleMtLrState);

		break;

		}

	// Handle network-related error

	// this function is stubbed for future expansion

	// coverity [dead_error_condition]

	if (CNetworkInterface::ENone != netError)

		{

		// coverity [dead_error_line]

		mtlrMachine.Observer().NetworkErrorReported();

		}

	}