// Copyright (c) 2007-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 specifies the states which can be used to form a
// Net Ups State Machine.
// @internalComponent
// @prototype
// 
//

#ifndef NETUPSSTATE_H
#define NETUPSSTATE_H

#include <e32def.h>		  					// defines TInt
#include <e32std.h>							// defines ThreadId, TProcessId

#include <comms-infras/ss_activities.h>

#include <comms-infras/ss_nodemessages.h> 	// defines ESock::TCFMessage
#include "netupstypes.h"		// defines TDestinationName, TNetUpsDecision

#include "netupstypes.h"					// defines TRequestId
#include "netupskeys.h"
#include "netupsdatabaseentry.h"
#include "netupsprocessentry.h"				// defines the database entry
#include "netupsthreadentry.h"				// defines the database sub entry
#include "netupsstatedef.h"					// defines the states for each state machine

#include <comms-infras/commsdebugutility.h> 		// defines the comms debug logging utility

namespace NetUps
{
class CNetUpsImpl;
class CUpsStateMachine;
NONSHARABLE_CLASS(CState)
	{
public:
	static CState* NewL(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);
	virtual ~CState();

	const TNetUpsState& State() const;
	CUpsStateMachine& 	UpsStateMachine();
	static void PerformStateTransition(TEvent aEvent, CProcessEntry& aProcessEntry);

	virtual void ProcessPolicyCheckRequestL(TThreadKey& aThreadKey, const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId aRequestId);		

	virtual void IncrementConnectionCountL(TCommsIdKey& aCommsIdKey); 
	virtual void DecrementConnectionCountL(TCommsIdKey& aCommsIdKey);

	virtual void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey,  MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	virtual void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey,  MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);
				
	virtual void HandleProcessTermination(TProcessKey& aProcessKey);
	virtual void HandleThreadTermination(TThreadKey& aThreadKey);

protected:
	CState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);
private:
	void ConstructL();
private:
	TNetUpsState 		iNetUpsState;
	CUpsStateMachine& 	iUpsStateMachine;

	__FLOG_DECLARATION_MEMBER;		
	};

NONSHARABLE_CLASS(CNullState) : public CState
	{
public:	
	void ProcessPolicyCheckRequestL(TThreadKey& aThreadKey, const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId aRequestId);		

	CNullState(CUpsStateMachine& aStateMachine);
	};

NONSHARABLE_CLASS(CProcLifeTime_NonSessionState) : public CState
	{
public:	
	void ProcessPolicyCheckRequestL(TThreadKey& aThreadKey, const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId aRequestId);			
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);	
	void HandleThreadTermination(TThreadKey& aThreadKey);

	CProcLifeTime_NonSessionState(CUpsStateMachine& aStateMachine);
	};

NONSHARABLE_CLASS(CProcLifeTime_SessionState) : public CState
	{
public:
	void HandleProcessTermination(TProcessKey& aProcessKey);

	CProcLifeTime_SessionState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);
	};

NONSHARABLE_CLASS(CProcLifeTime_TransitTo_SessionState) : public CProcLifeTime_SessionState
	{
public:
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);
	
	CProcLifeTime_TransitTo_SessionState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);
	};

NONSHARABLE_CLASS(CNetLifeTime_NonSessionState) : public CState
	{
public:	
	void ProcessPolicyCheckRequestL(TThreadKey& aThreadKey, const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId aRequestId);
	void DecrementConnectionCountL(TCommsIdKey& aCommsIdKey);
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);
	void HandleThreadTermination(TThreadKey& aThreadKey);

	CNetLifeTime_NonSessionState(CUpsStateMachine& aStateMachine);
	};	

NONSHARABLE_CLASS(CNetLifeTime_SessionYesState) : public CState
	{
public:	
	void DecrementConnectionCountL(TCommsIdKey& aCommsIdKey);

	CNetLifeTime_SessionYesState(CUpsStateMachine& aStateMachine);
protected:
	CNetLifeTime_SessionYesState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);	
	};	

NONSHARABLE_CLASS(CNetLifeTime_TransitTo_SessionYesState) : public CNetLifeTime_SessionYesState
	{
public:						
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey,  MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);

	CNetLifeTime_TransitTo_SessionYesState(CUpsStateMachine& aStateMachine);
	};

NONSHARABLE_CLASS(CNetLifeTime_SessionNo_WithOutConnectionsState) : public CState
	{
public:	
	void HandleProcessTermination(TProcessKey& aProcessKey);
	void DecrementConnectionCountL(TCommsIdKey& aCommsIdKey);

	CNetLifeTime_SessionNo_WithOutConnectionsState(CUpsStateMachine& aStateMachine);
protected:
	CNetLifeTime_SessionNo_WithOutConnectionsState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);
	};
	
NONSHARABLE_CLASS(CNetLifeTimeSession_TransitTo_SessionNoWithOutConnectionsState) : public CNetLifeTime_SessionNo_WithOutConnectionsState
	{
public:
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleThreadTermination(TThreadKey& aThreadKey);		
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);
	
	CNetLifeTimeSession_TransitTo_SessionNoWithOutConnectionsState(CUpsStateMachine& aStateMachine);
	};	

NONSHARABLE_CLASS(CNetLifeTime_SessionNo_WithConnectionsState) : public CState
	{
public:	
	void DecrementConnectionCountL(TCommsIdKey& aCommsIdKey);				

	CNetLifeTime_SessionNo_WithConnectionsState(CUpsStateMachine& aStateMachine);
protected:
	CNetLifeTime_SessionNo_WithConnectionsState(TNetUpsState aNetUpsState, CUpsStateMachine& aStateMachine);	
	};
	
NONSHARABLE_CLASS(CNetLifeTime_TransitTo_SessionNo_WithConnectionsState) : public CNetLifeTime_SessionNo_WithConnectionsState 
	{
public:
	void HandleUPSRequestCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision);
	void HandleUPSErrorOnCompletionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError);

	CNetLifeTime_TransitTo_SessionNo_WithConnectionsState(CUpsStateMachine& aStateMachine);
	};	

} // end namespace NetUps

#endif // NETUPSSTATE_H