// Copyright (c) 2008-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 SUPL Protocol Module.

// 

//

/**

 @file

 @internalTechnology

 @deprecated

*/

#include <in_sock.h>

#include "suplfsmsessionbase.h"

#include "suplstatehandlerbase.h"

#include <lbs/lbsnetclasstypes.h>

#include "supldevloggermacros.h"

#include "suplend.h"

#include <lbs/lbsextendedsatellite.h>

const TLbsHostCreatorId KUidLbsHostSettingsCreator = {0x10285A9D};

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

// State Machine Base Class

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

/** Standard constructor.

@param aObserver A reference to the state machine observer. 

*/  

CSuplFsmSessionBase::CSuplFsmSessionBase(MSuplFsmSessionObserver& aObserver)

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

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CSuplFsmSessionBase() Begin\n");

	ResetSessionId();

	iDefSettingsId.Null();

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CSuplFsmSessionBase() End\n");

	}

/** Standard destructor.

*/  

CSuplFsmSessionBase::~CSuplFsmSessionBase()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::~CSuplFsmSessionBase() Begin\n");

	if(iDefSettingsId!=TUid::Uid(KNullUidValue) && iSlpSettingsStore)

		{

		iSlpSettingsStore->DeleteHostSettings(iDefSettingsId);

		}

	Cancel();

	delete iEventStore;

	delete iStateHandler;

	delete iPositioningProtocol;

	iAssistanceDataBuilderSet.Close();

	delete iSlpSettingsStore;

	delete iMessageSessionId;

	delete iTelNumber;

	delete iSuplProtTimer;

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::~CSuplFsmSessionBase() End\n");

	}

/** Retrieve reference to state machine observer.

@return MSuplFsmSessionObserver A reference to the observer. 

*/  

MSuplFsmSessionObserver& CSuplFsmSessionBase::Observer()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::Observer() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::Observer() End\n");

	return iObserver;

	}

/** Set session ID

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

	the session ID is to be used.

*/

void CSuplFsmSessionBase::SetSessionId(const TLbsNetSessionId& aSessionId)

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SessionId() Begin\n");

	iSessionId = aSessionId;

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SessionId() End\n");

	}

/** Reset session ID

*/

void CSuplFsmSessionBase::ResetSessionId()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::ResetSessionId() Begin\n");

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

	iSessionId.SetSessionNum(0);

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::ResetSessionId() End\n");

	}

/** Get session ID

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

*/

const TLbsNetSessionId& CSuplFsmSessionBase::SessionId() const

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SessionId() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SessionId() End\n");

	return iSessionId;

	}

/** Obtain the session Id to be set in a call back to LBS

*/

const TLbsNetSessionId& CSuplFsmSessionBase::LbsSessionId() const

{

	// This base class just returns iSessionId

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::LbsSessionId() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::LbsSessionId() End\n");

	return iSessionId;

}

CSuplPositioningProtocolFsm* CSuplFsmSessionBase::PositioningFsm()

{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PositioningFsm() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PositioningFsm() End\n");

	return iPositioningProtocol;

}

/** Retrieve current general protocol state.

@return CSuplFsmSessionBase::TMachineState The current general 

	protocol state for this state machine.

@see CSuplFsmSessionBase::TMachineState

*/

CSuplFsmSessionBase::TMachineState CSuplFsmSessionBase::State() const

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::State() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::State() End\n");

	return iProtocolState;

	}

/** 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.

@return MLbsNetworkProtocolObserver::TLbsNetProtocolService request type.

*/

MLbsNetworkProtocolObserver::TLbsNetProtocolService CSuplFsmSessionBase::LocReqType() const

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::LocReqType() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::LocReqType() End\n");

	return iLocReqType;

	}

/** Initialise internal state machine attributes.

This is used when a new protocol procedure commences.

*/

void CSuplFsmSessionBase::InitialiseMachineBase()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::InitialiseMachineBase() Begin\n");

	iTransitionState = ETransitionNull;

	iProtocolState = EStateActive;

	iIsCancelPending = EFalse;

	iSessionConnected = EFalse;

	iCancelNoLongerAllowed = EFalse;

	ResetSessionId();

	// Clear store from any events that may remain

	// from previous session

	iEventStore->ClearStore();

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::InitialiseMachineBase() End\n");

	}

/** Complete state machine attributes.

This is used when a protocol procedure completes.

*/

void CSuplFsmSessionBase::CompleteMachineBase()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CompleteMachineBase() Begin\n");

	iProtocolState = EStateReady;

	// close connection

	iObserver.ConnectionManager().Disconnect(iSessionId.SessionNum());

	iSessionConnected = EFalse;

	// clear event store

	iEventStore->ClearStore();

	iSessionIdReplaced = EFalse;

	// Inform Protocol Manager that procedure is complete

	iObserver.ProcedureCompleteInd(LocReqType());

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CompleteMachineBase() End\n");

	}

/** Enter new state.

This asks the state handler to perform the actions required when

entering a new state.

*/  

TBool CSuplFsmSessionBase::NextStateEntryActionsL()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::NextStateEntryActionsL() Begin\n");

	ASSERT(iStateHandler);

	// Perform entry actions for the new state

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::NextStateEntryActionsL() End\n");

	return iStateHandler->EntryActionsL();

	}

/** Perform a transition.

This initiates a transition following either an external trigger

or a decision by the state machine that it must move on to the 

next state (self-transition).

If the transition has been due to an external event, the state machine

may yet decide to remain in the current state; @see SelectNextState()

*/  

void CSuplFsmSessionBase::PerformTransition()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PerformTransition() Begin\n");

	if (!IsActive())

		{

		iTransitionState = ETransitionEnter;

		DoTransitionStage();

		}

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PerformTransition() End\n");

	}

/** Do one stage of the state transition.

This employs a self-completion mechanism to perform one stage of

a state transition. The state machine object is set active and then its

own status is completed, which results in its RunL being called.

*/  

void CSuplFsmSessionBase::DoTransitionStage()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::DoTransitionStage() Begin\n");

	TRequestStatus* localStatus = &iStatus;

	iStatus = KRequestPending;

	SetActive();

	User::RequestComplete(localStatus, KErrNone);

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::DoTransitionStage() End\n");

	}

/** Returns ETrue if at least one of the positioning methods in a SUPL message

is within LBS' capabilities.

@param aPosMethod Positioning methods received in a SUPL message. A maximum of two positioning methods are expected.

@param aLbsCapabilities Positioning methods supported by LBS.

@param aSelected method. If the method returns ETrue, this variable will contain the network preferred

		         positioning method if supported by LBS, otherwise, the network alternative positioning.

		         method. This variable is not modified when the return value is EFalse.

@return ETrue if at least one method in aPosMethods is supported by LBS

*/

TBool CSuplFsmSessionBase::PosMethodSupported(const TLbsNetPosRequestMethod& aPosMethods, TLbsNetPosMethod& aSelectedMethod, const TLbsNetPosCapabilities& aLbsCapabilities)

{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PosMethodSupported() Begin\n");

	TInt index;

	TBool methodSupported = EFalse;

	TLbsNetPosMethod capPosMethod;

	TInt alternativeMethod = KErrNone;

	TLbsNetPosMethod netPrefMethod;

	TLbsNetPosMethod netAltMethod;

	// There must be a method preferred by the SUPL server

	if (KErrNone != aPosMethods.GetPosMethod(0, netPrefMethod))

		return methodSupported;

	// There may be an alternative method from the SUPL server

	alternativeMethod = aPosMethods.GetPosMethod(1, netAltMethod);

	// Loop through all of LBS-supported positioning methods

	for (index = 0; index < aLbsCapabilities.NumPosMethods(); index++)

		{

		aLbsCapabilities.GetPosMethod(index,capPosMethod);

		if (netPrefMethod.PosMeans() == capPosMethod.PosMeans() &&

			netPrefMethod.PosMode() == capPosMethod.PosMode())

			{

			// If the preferred network method is supported

			// just return it.

			aSelectedMethod = netPrefMethod;

			methodSupported = ETrue;

			break;

			}

		else if ((KErrNone != alternativeMethod) &&

				 (netAltMethod.PosMeans() == capPosMethod.PosMeans()) &&

		 		 (netAltMethod.PosMode() == capPosMethod.PosMode()))

			{

			aSelectedMethod = netPrefMethod;

			methodSupported = ETrue;

			}

		}

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::PosMethodSupported() End\n");

	return methodSupported;

}

/** Indicates if state machine is to be cancelled

@return TBool ETrue if machine is to be cancelled

*/

TBool CSuplFsmSessionBase::IsCancelPending() const

	{

	SUPLLOG2(ELogP1, "CSuplFsmSessionBase::IsCancelPending() = %d\n", iIsCancelPending);

	return iIsCancelPending;

	}

/** Set the status of the connection (connected or not)

@param aSessionConnected ETrue means the connection is up

*/

void  CSuplFsmSessionBase::SetSessionConnected(TBool aSessionConnected)

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetSessionConnected() Begin\n");

	iSessionConnected = aSessionConnected;

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetSessionConnected() End\n");

	}

/** Return the connection status

*/

TBool CSuplFsmSessionBase::IsSessionConnected()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::IsSessionConnected() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::IsSessionConnected() End\n");

	return iSessionConnected;

	}

/** Cancel state machine

@param aCancelSource The source that decided to cancel.

*/

void CSuplFsmSessionBase::CancelMachine(const TCancelSource& aCancelSource, const TCancelReason& aReason)

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CancelMachine() Begin\n");

	TBool forcedCancel = EFalse;

	if ((aCancelSource == CSuplFsmSessionBase::ECancelClosing))

		{

		// Cancel requested from RunError.

		// Set the machine as disconnected so there is no attempt to

		// send a SUPL END. This is to prevent the execution 

		// of leaving methods by the state machine from this point onwards.

		//

		iSessionConnected = EFalse;

		forcedCancel = ETrue;

		}

	// Always cancel if the cancel is forced.

	// Otherwise, only cancel if no cancel is in progress

	// and no cancel has already been requested

	// (only the first cancel source is considered)

	// and if cancel is allowed.

	if (forcedCancel ||

		((EStateCancelling != iProtocolState) && !iIsCancelPending && !iCancelNoLongerAllowed))

		{

		iIsCancelPending = ETrue;

		// Cancel the active procedure

		CancelProcedure();

        StoreCancelInfo(aCancelSource,aReason);

		// Perform state transition

		PerformTransition();

		}

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CancelMachine() End\n");

	}

/** Sets state machine attributes to represent cancelling

*/  

void CSuplFsmSessionBase::SetMachineAsCancelling()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetMachineAsCancelling() Begin\n");

	iIsCancelPending = EFalse;

	iProtocolState = EStateCancelling;

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetMachineAsCancelling() End\n");

	}

/** Sets state machine to not-cancellable

Derived state machines call this method after entering

some of the last states of the procedure when it no longer

make sense to accept cancel requests

*/  

void CSuplFsmSessionBase::SetMachineAsNotCancellable()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetMachineAsNotCancellable() Begin\n");

	iCancelNoLongerAllowed = ETrue;	

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetMachineAsNotCancellable() End\n");

	}

/** Check for a stored events.

Determine if there is an event stored and, if so, trigger

a transition to see if the event needs handling from

current state.

*/

void CSuplFsmSessionBase::CheckForStoredEvents()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CheckForStoredEvents() Begin\n");

	ASSERT(!IsActive()); // method only called when the AO is inactive

	// Check for a pending event when the machine is active

	if ((iProtocolState == EStateActive) && (!iEventStore->IsStoreEmpty()))

		{

		PerformTransition();

		}

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::CheckForStoredEvents() End\n");

	}

/** Active object completion handler

*/

void CSuplFsmSessionBase::RunL()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::RunL() Begin\n");

	SUPLLOG3(ELogP1, " iStatus=%d, iTransitionState=&d\n", iStatus.Int(), iTransitionState);

	TBool stateChanged = EFalse;

	TBool redoEntryActions = EFalse;

	TBool entryActionsConducted = EFalse;

	// Check we have completed ok

	if (KErrNone == iStatus.Int())

		{

		// Which stage of the transition is this?

		switch (iTransitionState)

			{

		// About to enter a state

		case ETransitionEnter:

			// Reset transition state value

			iTransitionState = ETransitionNull;

			// Perform state machine transition.

			stateChanged = SelectNextState(redoEntryActions);

			// Execute next state entry actions only if a

			// cancel has not been requested from 

			// SelectNextState() due to unexpected message.

			if (!iIsCancelPending)

				{

				if (stateChanged || redoEntryActions)  

					{

					entryActionsConducted = NextStateEntryActionsL();				

					}

				}

			// Perform state machine post-transition actions

			// Note: this will initiate a transition out of states

			// that perform self-transition.

			PostTransition();

			// When the state machine is not active (it is waiting

			// for an external trigger) check if there are

			// any stored events to be handled that may provoke

			// a transition.

			if (!IsActive())

				{

				// If the last transition neither changed state

				// nor was conductive to any actions then it can

				// be assumed that there are no pending events that 

				// can be handled from the current state (a transition  

				// can only be triggered by a new event)

				if (stateChanged || entryActionsConducted)

					{

					CheckForStoredEvents();

					}

				}

			break;

		// Not changing state just performing asynchronous activities

		// or waiting for new events

		case ETransitionNull:

		default:

			// Empty intentionally

			break;

			};

		}

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::RunL() End\n");

	}

/** Active object completion handler

*/

void CSuplFsmSessionBase::RunError()

{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::RunError() Begin\n");

	CancelMachine(ECancelClosing,EReasonNone);

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::RunError() End\n");

}

/** Active object cancellation handler

*/

void CSuplFsmSessionBase::DoCancel()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::DoCancel() Begin\n");

	iStatus = KErrCancel;

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::DoCancel() End\n");

	}

/** Retrieve Stored Message Session Id

@return Pointer to the stored message session ID object

*/

CSuplSessionId* CSuplFsmSessionBase::MessageSessionId()

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::MessageSessionId() Begin\n");

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::MessageSessionId() End\n");

	return iMessageSessionId;

	}

/** Store Message Session Id

@return Pointer to the stored message session ID object

*/

void CSuplFsmSessionBase::SetMessageSessionId(CSuplSessionId* aMessageSessionId)

	{

	SUPLLOG(ELogP1, "CSuplFsmSessionBase::SetMessageSessionId() Begin\n");

	// Delete old session Id, take ownership of the new one

	if (iMessageSessionId != NULL)

		{

		delete iMessageSessionId;		

		}

	iMessageSessionId = aMessageSessionId;