// 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 defines the base class for SUPL protocol state machines.

// 

//

/**

 @file

 @internalTechnology

 @deprecated

*/

#ifndef __SUPLFSMSESSIONBASE_H__

#define __SUPLFSMSESSIONBASE_H__

#include <e32base.h>

#include <lbspositioninfo.h>

#include <lbs/lbsnetprotocolbase.h>

#include <lbs/lbsnetcommon.h>

#include <lbs/lbsloccommon.h>

#include "lbstimer.h"

#include <etelmm.h>

#include "suplmessagebase.h"

#include "suplpospayload.h"

#include "suplconnectionmanager.h"

#include "suplpositioningprotocolfsm.h"

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

// State Machine Base Class

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

class CSuplFsmEventStore;

class CSuplStateHandlerBase;

class MSuplProtocolManagerObserver;

/** KSuplPosTimerEvent

Identity of timer for when SUPL POS is expected from the network

*/

const TInt KSuplPosTimerEvent = 0x200;

/** KSuplPosTimerDurationInSecTimerDurationInSec

Timer duration for when SUPL POS is expected from the network

after having sent out a SUPL POS INIT.

*/

const TInt KSuplPosTimerDurationInSecTimerDurationInSec = 10;

/** KSuplEndTimerEvent

Identity of timer for when SUPL END is expected from the network

*/

const TInt KSuplEndTimerEvent = 0x400;

/** KSuplEndTimerDurationInSecTimerDurationInSec

Timer duration for when SUPL END is expected from the network

after having sent out the last SUPL POS.

*/

const TInt KSuplEndTimerDurationInSecTimerDurationInSec = 10;

/** KSessionConnectedTimerEvent

Identity of timer for when connection confirmation expected from Connection Manager

*/

const TInt KSessionConnectedTimerEvent = 0x300;

/** KSessionConnectedTimerDurationInSec

Timer duration for when connection confirmation expected from Connection Manager

*/

const TInt KSessionConnectedTimerDurationInSec = 15;

/** SUPL State Machine observer mixin definition.

This class used by the SUPL state machines to communicate with

their observer, the Protocol Manager.

*/

class MSuplFsmSessionObserver

{

public:

	virtual MSuplProtocolManagerObserver& Gateway() = 0;

	virtual CSuplConnectionManager& ConnectionManager() = 0;

	virtual const TLbsNetSessionId& NewSessionId() = 0;

	virtual void ProcedureCompleteInd(const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aService) = 0;

	virtual void LocationReq(const TLbsNetSessionId& aSessionId, 

					 		 const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aType, 

					 		 const TLbsNetPosRequestQuality& aQuality, const TLbsNetPosRequestMethod& aPosMethod) = 0;

	virtual void ProcessAssistanceData(const TLbsAsistanceDataGroup& aGroupMask, 

							   		   const RLbsAssistanceDataBuilderSet& aData,const TInt& aReason,

							  		   const MLbsNetworkProtocolObserver::TLbsNetProtocolService& aService) = 0;

	virtual void PrivacyReq(const TLbsNetSessionId& aSessionId,

							const TLbsNetPosRequestPrivacy& aPrivacy,

							const TLbsExternalRequestInfo& aRequestInfo) = 0;

};

/** Base class definition for SUPL protocol state machines.

This class provides support for common features of all state machines.

A significant aspect incorporated in this base class is the active object

mechanism for performing state transitions. This feature is used to allow 

event-handling methods to return inmediately after storing the event, relying

on later execution of RunL for the real handling of the events.

This approach keeps the Network Gateway responsive to new events.

Another benefit of the Active Object paradigm is that it provides state

machines with the ability to perform autonomous and asynchronous actions.

In RunL, state transitions are followed by the execution of the entry actions of the

next state. Each state's entry actions are designed to be completed in a short time.

This staged approach ensures that lengthy protocol module

activity is broken down into shorter steps, thereby releasing the active

scheduler to process other active objects in the NG thread. A self-completion

approach is employed to achieve this. @see CSuplFsmSessionBase::DoTransitionStage()

The base class includes various attributes that describe protocol activity,

together with access methods used to retrieve the value of these attributes.

External events and their associated parameters are kept in the Event Store

to be used for the length of the sessio as required. @see CSuplFsmEventStore

*/

NONSHARABLE_CLASS(CSuplFsmSessionBase) : public CActive, public MSuplConnectionManagerObserver,

										 public MSuplPositioningProtocolFsmObserver,

										 public MLbsCallbackTimerObserver

	{

public:

	/** State machine protocol state.

	This defines the general protocol state for state machines.

	*/

	enum TMachineState

		{

		/** Not valid */

		EStateNull,

		/** Ready to use, but not currently active. */

		EStateReady,

		/** Actively performing a protocol procedure. */

		EStateActive,

		/** In the process of cancelling. */

		EStateCancelling

		};

	/** SUPL specific states

	These identify the current state within the

	MO-LR or MT-LR protocol procedure.

	*/

	enum TSuplProcedureState

		{

		/** Idle */

		EStateProcedureNull,

		// ----------------- MOLR-ONLY STATES ----------------------------------------

		/** Trigger: Connected to SLP. Action: SUPL START sent*/

		EStateStartSent,

		/** Trigger: SUPL RESPONSE received. Action: Request sent to LBS.*/

		EStateResponseReceived,

		// ----------------- MTLR-ONLY STATES ---------------------------------------

		/** Trigger: SUPL INIT message received. Action: Send privacy request to LBS*/

		EStateSuplInitReceived,

		//------------------ STATES COMMON TO MOLR AND MTLR --------------------------

		/** Trigger: Privacy Response received from LBS allowing MTLR or self location requested.

		    Action: Initiate a network session */

		EStateNetConnectionStarted,

		/** Trigger: LBS requested Assistance data or provided a result. Action: SUPL POS INIT sent */

		EStatePosInitSent,

		/** Trigger: SUPL END with position received. Action: forward received position to LBS */

		EStatePositionReceived,

		/** Trigger: SUPL POS received. Actions: relay messages between Positioning FSM, LBS and network */

		EStatePositioningInProgress,

		/** Trigger: errors or client cancel while connected. Actions: send SUPL END*/

		EStateSuplSessionEnded,

		/** Trigger: session has terminated. Actions: instruct positioning FSM to halt*/

		EStatePosSessionEnded,

		/** Trigger: session has terminated. Actions: termination of LBS session */

		EStateLbsSessionEnded,

		/** Trigger: session has terminated. Action: termination of network session */

		EStateNetConnectionClosed

		};

	/** State machine cancel source.

	This defines the source of a cancellation.

	*/

	enum TCancelSource

		{

		/** Not cancelling */

		ECancelNone,

		/** The LBS client cancelled the procedure */

		ECancelClient,

		/** A network error occurred */

		ECancelNetwork,

		/** A positioning protocol error occurred*/

		ECancelPosProt,

		/** An SUPL protocol state machine encountered an error*/

		ECancelSuplProt,

		/** State machine is closing down (destruction)*/

		ECancelClosing

		};

	enum TCancelReason

		{

		/** Reason not specified */

		EReasonNone,

		/** A protocol has received an unexpected message */

		EReasonUnexpectedMessage,

		/** A timer has expired */

		EReasonTimerExpiry,

		/** The connection is down */

		EReasonDisconnected,

		/** The connection manager can't connect to remote server

		with LBS's minimun security requirements*/ 

		EReasonInsuficcientSecurity,

		/** A SUPL server could not be found in the host settings DB*/

		EReasonSlpSettingsMissing,

		/** Parsing error decoding a received SUPL message */

		EReasonParsingError,

		/** Mandatory data missing in received SUPL message*/

		EReasonDataMissing,

		/** A value in a received message is out of range or corrupted*/

		EReasonUnexpectedDataValue,

		/** No supported positioning methods in received SUPL message*/

		EReasonMethodMismatch,		

		/** Received SUPL message contains invalid sessionID*/

		EReasonInvalidSessId,

		/** Mandatory info for outgoing message is not available */

		EReasonDataUnavailable,

		/** LBS rejected a privacy request*/

		EReasonPrivacyRejected,

		/** LBS wants a privacy request to be ignored*/

		EReasonPrivacyIgnored,

		/** LBS declares itself unable to calculate the position **/

		EReasonFutilePosCalc

		};

protected:

	/** State transition stage.

	This defines the individual stages used when a state machine makes a

	transition from one state to another. This approach allows the state

	machine to perform a number of asynchronous actions without making 

	any call to RunL too lengthy.

	*/

	enum TTransitionStage

		{

		/** Not in a transition */

		ETransitionNull,

		/** Enter new state */

		ETransitionEnter

		};

public:

	virtual ~CSuplFsmSessionBase();

	// Methods that can be overriden in derived classes

	//

	/** Complete state transition.

	Derived classes implement a method to perform actions after a state transition.

	*/

	virtual void PostTransition() = 0;

	/** Change state.

	Derived classes implement a method to select the next state following an event.

	The next state selected may (rarely) be the same as the current state, in which case

	parameter aForceRedo indicates that the entry actions for the state must be

	performed again. 

	*/

	virtual TBool SelectNextState(TBool& aForceRedo) = 0;

	/** Cancel the active procedure.

	Derived classes implement a method to cancel the active procedure.

	*/

	virtual void CancelProcedure() = 0;

	/** A location response from LBS has been received.

	Derived classes implement a method to handle this response, with due

	consideration of the prevailing state machine activity.

	*/

	virtual void LocationResp(TInt aReason, const TPositionInfoBase& aPosInfo) = 0;

	virtual void AssistanceDataReq(const TLbsAssistanceDataGroup& aFilter) = 0;

	// Derived from MSuplConnectionManagerObserver. Implemented by concrete state machines

	// with due consideration of the prevailing state machine activity.

	void Connected(const TInetAddr& aIpAddress);

	void ConnectionError(const TSuplConnectionError& aError);

	void MessageReceived(CSuplMessageBase* aSuplMessage);

	// Derived from MSuplPositioningProtocolFsmObserver. 

    virtual void ProcessAssistanceData(const TLbsAsistanceDataGroup& aGroupMask, TInt aReason) = 0;

	virtual void ProcessPositioningRequest(const TLbsNetPosRequestQuality& aQuality,

										   const TLbsNetPosRequestMethod& aPosMethod) = 0;					

	virtual void PositioningPayloadToNetwork(const CSuplPosPayload* aPositioningPayload) = 0;

	virtual void PositioningProtocolError(const TInt& aError) = 0;

	void PositioningSessionEnded();

	// Methods called by State Handlers and Protocol Manager

	virtual void CompleteProcedure() = 0;

	virtual const TLbsNetSessionId& LbsSessionId() const;

	void StartConnectionTimer();

	void StartSuplPosTimer();

	void StartSuplEndTimer();

	void SetSessionInProgress(TBool aSessionInProgress);

	CSuplFsmSessionBase::TSuplProcedureState CurrentState();

	CSuplSessionId* MessageSessionId();

	void SetMessageSessionId(CSuplSessionId* aMessageSessionId);

	virtual TInt GetHostId(TLbsHostSettingsId& aHostId) = 0;

	void SetSessionId(const TLbsNetSessionId& aSessionId);

	CSuplPositioningProtocolFsm* PositioningFsm();

	const TLbsNetSessionId& SessionId() const;

	TBool IsSessionConnected();

	virtual void CancelMachine(const TCancelSource& aCancelSource,const TCancelReason& aReason);	

	MSuplFsmSessionObserver& Observer();

	TMachineState State() const;

	MLbsNetworkProtocolObserver::TLbsNetProtocolService LocReqType() const;

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

public:

	// Methods for storing and retrieving event-related data from the store

	//

	TInt StoreLocationRequest(const TLbsNetPosRequestOptionsBase& aOptions);

	void StoreAssistanceDataRequest(const TLbsAssistanceDataGroup& aFilter);

	void StoreSuplMessage(const CSuplMessageBase* aMessage);

	void StorePosPayload(const CSuplPosPayload* aPayload);

	void StoreCancelInfo(const CSuplFsmSessionBase::TCancelSource& aSource,

							const CSuplFsmSessionBase::TCancelReason& aReason);

	void StoreNetInfo(const RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

					  const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea);

	void StoreMccMnc(TUint aMcc, TUint aMnc);

	void StoreMsisdn(const TDesC& aTelNumber);

	void StoreCellInfo(const RMobilePhone::TMobilePhoneCellInfoV9& aCellInfo);

	void StorePositioningEnded(TBool aPosEnded);

	TBool RetrieveLocationRequestOptions(TLbsNetPosRequestOptions& aOptions);

	TBool RetrieveAssistanceDataRequest(TLbsAssistanceDataGroup& aAssitDataMask);

	void RetrieveStoredNetworkInfo(RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

								   RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea);

	TBool RetrieveStoredCellInfo(RMobilePhone::TMobilePhoneCellInfoV9& aCellInfo);

	const CSuplMessageBase* RetrieveSuplMessage();

	const CSuplPosPayload* RetrievePosPayload();

	const TInetAddr& RetrieveLocalIpAddress();

	void RetrieveCancelInfo(CSuplFsmSessionBase::TCancelSource& aSource,

							CSuplFsmSessionBase::TCancelReason& aReason);

	void RetrievePrivacyAdvice(TLbsNetPosRequestPrivacy& aPrivacy);

	void RetrieveRequestorInfo(TLbsExternalRequestInfo& aRequestor);

	void RetrieveInitPosMethod(TLbsNetPosRequestMethod& aPosMethod);

	void RetrieveInitQuality(TLbsNetPosRequestQuality& aQuality);

	void RetrieveVer(TDes8& aVer);

	TPositionInfoBase* RetrievePositionL();

	TBool RetrievePositioningSessionEnded();

	TBool IsUnexpectedSuplEndStored();

	TBool IsAssistanceDataRequestStored();

	TBool IsNetworkInfoAvailable();

	TBool IsPositionStored();

	TBool PosSessionConducted();

	inline const TDesC* Msisdn() const;

protected:

	CSuplFsmSessionBase(MSuplFsmSessionObserver& aObserver);

	void InitialiseMachineBase();

	void CompleteMachineBase();

	void  SetSessionConnected(TBool aSessionConnected); 

	TBool IsCancelPending() const;

	void SetMachineAsCancelling();

	void SetMachineAsNotCancellable();

	TInt GenerateHostId(TLbsHostSettingsId& aHostId);

	TInt OnTimerError(TInt aTimerId, TInt aError);

	TBool DetermineStateFromPosInitSent();

	TBool DetermineStateFromPositioningInProgress(TBool& aForceRedo);

	void PerformTransition();

private:

	void ResetSessionId();

	void DoTransitionStage();

	void CheckForStoredEvents();

	TBool NextStateEntryActionsL();

	void GenerateHostIdL(TLbsHostSettingsId& aHostId);

	// CActive derived methods

	void RunL();

	void RunError();

	void DoCancel();

protected:

	/** Reference to State machine observer

	*/

	MSuplFsmSessionObserver& iObserver;

	/** Local store for buffering external events

		that are likely to trigger state transitions.

	*/

	CSuplFsmEventStore* iEventStore;

	/** Pointer to state handler.

	This is owned by the derived classes that create state handlers.

	*/

	CSuplStateHandlerBase* iStateHandler;

	/** Current machine state.

	*/

	TMachineState iProtocolState;

	/** Current state of the SUPL procedure (MO-LR or MT-LR)

	*/

	TSuplProcedureState iCurrentState;

	/** Session ID.

	Session Id at the beginning of the session. This number is always used

	in messages sent to the network.

	*/

	TLbsNetSessionId iSessionId;

	/** State transition stage enumeration.

	*/

	TTransitionStage iTransitionState;

	/** Flag to indicate if state machine is to be cancelled.

	*/

	TBool iIsCancelPending;

	/** Flag to indicate that the machine cannot be cancelled. Derived

	state machines set this variable to true when they have reached

	late stages of the procedure and no longer makes sense to cancel.

	*/

	TBool iCancelNoLongerAllowed;

	/** Location request type.

	*/

	MLbsNetworkProtocolObserver::TLbsNetProtocolService iLocReqType;

	/** Flag to show that this session has an active

	    connection with a server

	*/

	TBool iSessionConnected;

	/** Positioning Protocol State Machine (RRLP)

	*/

	CSuplPositioningProtocolFsm* iPositioningProtocol;

	/** Assistance Data Builder 

	Passed to the positioning FSM for it to set assistance data in.

	*/

	RLbsAssistanceDataBuilderSet iAssistanceDataBuilderSet;

	/** The id of default settings generated using MCC and MNC*/

	TLbsHostSettingsId iDefSettingsId; 

	/** Store of settings for available SLPs to contact */

	CLbsHostSettingsStore* iSlpSettingsStore;

	/** When this flag is true, all the messages sent to LBS must contain

	the session ID in iReplacementSessionId, otherwise iSessionId.

	*/

	TBool iSessionIdReplaced;

	/** LBS replacement session ID.

	Session Id to be used in all communications with LBS when iSessionIdReplaced

	is true. Changing the session Id halfway through an MOLR session may 

	be required due to conflicting self-locate requests.

	*/

	TLbsNetSessionId iReplacementSessionId;	

	/** Timer used for monitoring arrival of 

	SUPL messages.

	*/

	CLbsCallbackTimer* iSuplProtTimer;

	/** Flag that is set to true from the moment a SUPL START

    is sent or a SUPL INIT is received until the moment a

    SUPL END is received or sent.

    */

	TBool iSessionInProgress;

	/** Used to keep the SLP session Id */

	CSuplSessionId* iMessageSessionId;

	/** The MCC of the home network */

	TUint iMcc;

	/** The MNC of the home network */

	TUint iMnc;

	/** The telephone number */

	HBufC* iTelNumber;

	};

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

// State Machine Event Store Class

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

/** State machine event store.

This is used to hold external events that require asynchronous actions until the

state machine is next in a position to be able to service each event, at which

point the event is removed from the store.

All the memory required is allocated on creation. Dynamic arrays are used for

convenience as they provide a useful inteface but they are prevented from allocating

memory at runtime.

*/

NONSHARABLE_CLASS(CSuplFsmEventStore) : public CBase

{

public:

	static CSuplFsmEventStore* NewL(TInt aMaxEntries);

	~CSuplFsmEventStore();