/**

* Copyright (c) 2003-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:

* Header for PSD States

* 

*

*/

/**

 @file PSDStates.h

 @internalComponent

*/

#ifndef __PSDSTATES_H__

#define __PSDSTATES_H__

#include <comms-infras/dialogprocessor.h>

#include <etelpckt.h>

#include "psdagt.h"

#include "PSDAGTBase.h"

class MPsdEnv;

class MPsdCommDbAccess;

class CPsdInitBase : public CAgentStateBase

/**

Base class for classes performing the initialisation state for both

incomming and outgoing connections

@internalComponent

*/

	{

public:

	CPsdInitBase(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdInitBase();

	virtual void StartState();

protected:

	virtual void DoStartStateL();

	void GetPhoneInfoL(const TDesC& aLoadedTsyName, RTelServer::TPhoneInfo& aInfo);

	virtual void RunL();

	virtual void DoCancel();

protected:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdOutInit : public CPsdInitBase

/**

Class implementing the initialisation state for outgoing connections

@internalComponent

*/

	{

public:

	CPsdOutInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdOutInit();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

	};

#ifndef INCOMING_NOT_SUPORTED

class CPsdInInit : public CPsdInitBase

/**

Class implementing the initialisation state for incomming connections

@internalComponent

*/

	{

public:

	CPsdInInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdInInit();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	virtual void DoStartStateL();

	};

#endif // #ifndef INCOMING_NOT_SUPORTED

class CPsdCheckConfig : public CAgentStateBase

/**

Base class for classes performing the config checking state for both

incomming and outgoing connections

@internalComponent

*/

	{

public:

	CPsdCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdCheckConfig();

	virtual void StartState();

protected:

	virtual void DoInitL();

	virtual void RunL();

	virtual void DoCancel();

protected:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdOutCheckConfig : public CPsdCheckConfig

/**

Class implementing the config checking state for outgoing connections

@internalComponent

*/

	{

public:

	CPsdOutCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdOutCheckConfig();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

	};

#ifndef INCOMING_NOT_SUPORTED

class CPsdInCheckConfig : public CPsdCheckConfig

/**

Class implementing the config checking state for incomming connections

@internalComponent

*/

	{

public:

	CPsdInCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdInCheckConfig();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

	};

#endif // #ifndef INCOMING_NOT_SUPORTED

class CPsdNetworkCheck : public CAgentStateBase

/**

Class implementing the network check state. Responsible for ensuring that 

the network is in a suitable state before advancing the state machine

@internalComponent

*/

	{

public:

	CPsdNetworkCheck(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdNetworkCheck();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	void DoNetworkCheck();

private:

	RPacketService::TRegistrationStatus iRegStatus;

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	enum

	{EGettingInitialStatus,EWaitingForStatusChange} iSubState;

	};

#ifndef INCOMING_NOT_SUPORTED

class CPsdWaitForIncoming : public CAgentStateBase

/**

Class implementing the wait for incomming state. Used in incomming connections

it is responsible for listening out for an incomming connection, validating the 

connection and advancing the state machine.

@internalComponent

*/

	{

public:

	CPsdWaitForIncoming(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdWaitForIncoming();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	RPacketContext::TProtocolType iPdpTypeRequested;

	RPacketContext::TProtocolAddress iAddressRequested;

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

#endif // #ifndef INCOMING_NOT_SUPORTED

class CPsdCreateContext : public CAgentStateBase

/**

Class implementing the create context state. Responsible for creating the 

context and configuring it with the correct parameters

@internalComponent

*/

	{

public:

	CPsdCreateContext(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdCreateContext();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdCreateQoS : public CAgentStateBase

/**

Class implementing the create QoS state. Responsible for creating the 

QoS and configuring it with the correct parameters

@internalComponent

*/

	{

public:

	CPsdCreateQoS(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdCreateQoS();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdActivateContext : public CAgentStateBase

/**

Class implementing the activate context state. Responsible for activating

the previously configured context

@internalComponent

*/

	{

public:

	CPsdActivateContext(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdActivateContext();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	enum

	{EActivatingContext,ELoaningCommPort} iSubState;

	RCall::TCommPort iCommport;

	};

class CDataLogger;

class CPsdOpen : public CAgentStateBase, public MPsdContextChangeObserver, public MDialogProcessorObserver

/**

Class implementing the open state. Responsible for maintaining the connection

reporting progress and logging

@internalComponent

*/

	{

public:

	static CPsdOpen* NewL(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdOpen();

	// From CAgentStateBase

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

	// from MPsdContextChangeObserver

	virtual void ReportContextBelowAcceptableQuality();

	virtual void ReportError(TInt aError);

	 // from MDialogProcessorObserver

	virtual void MDPOQoSWarningComplete(TInt aError, TBool aResponse);

private:

	void RequestStatusChange();

	CPsdOpen(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	void ConstructL();

	void LogActive();

	void WatchForConfigChangesL();

protected:

	void RunL();

	void DoCancel();

private:

	RPacketContext::TContextStatus iContextStatus;

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	TBool iEventLoggerStarted;

	CPsdContextChangeMonitor* iContextChangeMonitor;

	};

class CPsdRecoverCommPort : public CAgentStateBase

/**

Class implementing the recover comm port state. First state during

disconnection it is responsible for recovering the previously loaned

comm port

@internalComponent

*/

	{

public:

	CPsdRecoverCommPort(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdRecoverCommPort();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdCloseLog : public CAgentStateBase

/**

Class implementing the close log state. Responsible for the discontinuation

of logging

@internalComponent

*/

	{

public:

	CPsdCloseLog(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdCloseLog();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	enum

	{EStart,ELoggingFinalValues,EEndingLog} iSubState;

	};

class CPsdDeactivation : public CAgentStateBase

/**

Class implementing the deactivation state. Responsible for deactivating the

context

@internalComponent

*/

	{

public:

	CPsdDeactivation(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdDeactivation();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	};

class CPsdClosure : public CAgentStateBase

/**

Class implementing the closure state. Responsible for cleaning up all the

resources used for the connection

@internalComponent

*/

	{

public:

	CPsdClosure(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb);

	virtual ~CPsdClosure();

	virtual void StartState();

	virtual CAgentStateBase* NextStateL(TBool aContinue);

protected:

	void RunL();

	void DoCancel();

private:

	MPsdEnv* iSM;

	MPsdCommDbAccess* iDbPsd;

	enum

	{EClosureStart,EDeletingContext,EClosureEnd} iSubState;

	};

#endif