--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyprotocols/gprsumtsqosprt/inc/async_request.h	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,330 @@
+// 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:
+//
+
+#ifndef __ASYNC_REQUEST_H__
+#define __ASYNC_REQUEST_H__
+
+#include <networking/umtsnifcontrolif.h>
+#include "extension.h"
+#include "guqos_log.h"
+
+enum TRequest
+	{
+	EPendingAny = 0,
+	EPendingCreate,
+	EPendingDelete,
+	EPendingConfig,
+	EPendingSetQoS,
+	EPendingModifyActive,
+	EPendingActivate,
+	EPendingPacketFilterAdd,
+    EPendingPacketFilterRemove,
+    EPendingSblpParameterAdd,       // Request for adding sblp parameter
+    EPendingSblpParameterRemove,    // Request for removing sblp parameter
+	EPendingTFTRemove,
+	EPendingCancel,
+	EPendingNone
+	};
+
+class CFlowData;
+class CPdpContext;
+class CNif;
+
+template <class T>
+struct SActionStep 
+	{
+	/**
+	* An action of the state machine.
+	*
+	* Its it up to the action whether parameters are used or not. When the
+	* state machine is started, the parameters are both NULL, as there is
+	* no preceding event from NIF. Thus, the first action(s) usually ignore
+	* the parameters.
+	*
+	* The aContext parameter is initially NULL and upon each event reply
+	* from the NIF, it is filled with the related context. Action can
+	* change the current context for the subsequent actions using
+	* CRequestBase::SetContext . This change persists for the duration
+	* of the current CRequestBase::Run or CRequestBase::Start .
+	*
+	* @param aContext The context
+	* @param aParams  NULL or the parameters of the event from NIF
+	*
+	* @return
+	*	@li EFalse - No action activated, proceed to the next state
+	*	@li ETrue - Action activated. Action can be completion and
+	*		destruction of the request object. Thus, when action
+	*		returns ETrue, the member variables of the current
+	*		request MUST NOT BE REFERENCED.
+	*/
+	TBool (T::*iAction)(CPdpContext* aContext, const TContextParameters* aParams);
+	/**
+	* Expected result, if action activated.
+	* When action activates some NIF Control request, this code specifies the
+	* type of the expected result. When the event arrives, this code can be
+	* checked in the Run() function.
+	*/
+	//TRequest iRequest;
+	};
+
+// Base class for async requests: separate flow-specific and channel-specific requests?
+class CRequestBase : public CBase
+	{
+protected:
+	virtual ~CRequestBase();
+public:
+	CRequestBase(CNif& aNif);
+
+	virtual void Start();
+	void Run(const TRequest aRequest, CPdpContext* aPdpContext, const TContextParameters& aParams);
+	virtual TBool Action(CPdpContext* aPdpContext, const TContextParameters* aParams) = 0;
+
+	virtual void Cancel(CFlowData* aFlowData);
+	virtual void Cancel(CPdpContext* aContext) = 0;
+
+    TBool IsOk(TInt aResult, CPdpContext *aContext);
+
+    void CompleteAndDestruct(TInt aErrorCode, const TQoSParameters* aParams, const TExtensionData& aExtension=TExtensionData());
+
+
+	TSglQueLink iLink;
+protected:
+	virtual void Failure(CPdpContext* aPdpContext, TInt aErrorCode);
+
+	void SetContext(CPdpContext *aContext);
+	void SetExpected(const TRequest aRequest);
+
+	TBool ActionRemovePacketFilter(CPdpContext*, const TContextParameters*);
+
+	TBool ActionAddPacketFilter(CPdpContext*, const TContextParameters*);
+	TBool DoAddFlowToContext(CPdpContext*, const TContextParameters*);
+	TBool ActionCommit(CPdpContext*, const TContextParameters*);
+	TBool ActionRequestComplete(CPdpContext*, const TContextParameters*);
+
+	RExtensionData iExtension;		// Extension Data for the completion message
+	MQoSNegotiateEvent* iNotify;
+	CNif& iNif;
+
+	//
+	// The state machine information
+	//
+	TInt iState;		// Current State number [0...]
+	/**
+	* Associated flow, or NULL, if none.
+	*
+	* Some actions may use a flow as an additional input. The validity
+	* of this is at responsibility of the request implementation.
+	*/
+	CFlowData* iFlow;
+	/**
+	* The context has been modified.
+	*
+	* iContextModified is TRUE, when the iContext has queued modifications in NIF.
+	* This only controls whether ModifyActive can be skipped in ActionCommit.
+	*
+	* This is currently automaticly set whenever SetExpected is called,
+	* and cleared when iContext is changed.
+	*/
+	TBool iContextModified;
+private:
+	/**		
+	* The expected event completion.
+	*
+	* This value is defined only when some request has been passed to
+	* NIF Control() and then the value is the expected reply event
+	* from the NIF.
+	*/
+	TRequest iExpected;
+	/**
+	* The current context being acted on (or NULL).
+	*
+	* This value is defined only when executing the actions (e.g. while
+	* executing Run or Start. In other times, it is just left over
+	* value that might point to already destroyed context and must
+	* never be used.
+	*/
+	CPdpContext* iContext;
+	/**
+	* The current context parameters from NIF (or NULL)
+	*
+	* This value is defined only when executin Run().
+	*/
+	const TContextParameters* iParams;
+#ifdef _LOG
+	//
+	// For DEBUG / LOGGING purposes only
+public:
+	const TDesC* iName;	// Name must be set by the constructor of each derived class.
+#endif
+	};
+
+
+// Remove unneeded TFT's from the context
+class CClose : public CRequestBase
+	{
+	~CClose();
+public:
+	static CClose* New(CPdpContext& aContext);
+
+	virtual void Start();
+	virtual TBool Action(CPdpContext* aContext, const TContextParameters* aParams)
+		{return (this->*iActionList[iState].iAction)(aContext, aParams); }
+
+	virtual void Cancel(CPdpContext* aContext);
+
+protected:
+	CClose(CPdpContext& aContext);
+
+private:
+	static const SActionStep<CClose> iActionList[];
+	CPdpContext& iClosing;
+	};
+	
+// Context deletion requst
+class CDeleteRequest : public CRequestBase
+	{
+public:
+	static CDeleteRequest* NewL(CPdpContext* aContext);
+	
+	virtual void Start();
+	// This request has no "action list", it's all done in Start()
+	virtual TBool Action(CPdpContext*, const TContextParameters*) {return ETrue; }
+	virtual void Cancel(CPdpContext* aContext);
+protected:
+	CDeleteRequest(CPdpContext* aContext);
+private:
+	CPdpContext *iDelete;
+	};
+
+// Intermediate shared class for requests that negotiate QoS
+class CNegotiationBase : public CRequestBase
+	{
+protected:
+	~CNegotiationBase() {}
+public:
+	void SetParameters(const TQoSParameters& aParams, CExtensionPolicy& aPolicy);
+    void SetParametersFlowExtn(CExtensionPolicy &aPolicy);
+protected:
+ 	CNegotiationBase(CNif& aNif);
+	void Failure(CPdpContext* aPdpContext, TInt aErrorCode);
+
+
+	TBool ActionAddSblpParameter(CPdpContext*, const TContextParameters*);
+	TBool ActionSetQoS(CPdpContext*, const TContextParameters*);
+	TBool ActionNegotiationComplete(CPdpContext *, const TContextParameters*);
+
+    TBool iSblp;
+	RFlowExtensionParams  iFlowExtnParams;
+	TQoSParameters	iGeneric;
+	TQoSRequested	iUmts;
+	};
+
+
+class COpenChannel : public CNegotiationBase
+	{
+	~COpenChannel();
+public:
+	static COpenChannel* New(TUint aChannelId, CFlowData &aFlow, MQoSNegotiateEvent* aNotify);
+
+
+	virtual void Start();
+	virtual TBool Action(CPdpContext* aContext, const TContextParameters* aParams)
+		{return (this->*iActionList[iState].iAction)(aContext, aParams); }
+
+	virtual void Failure(CPdpContext* aPdpContext, TInt aErrorCode);
+	virtual void Cancel(CPdpContext* aContext);
+
+protected:
+	COpenChannel(TInt aChannelId, CFlowData& aFlow, MQoSNegotiateEvent* aNotify);
+
+	TBool ActionNewContext(CPdpContext*, const TContextParameters*);
+	TBool DoRememberCreatedContext(CPdpContext*, const TContextParameters*);
+
+private:
+
+	static const SActionStep<COpenChannel> iActionList[];
+
+	const TInt iChannelId;
+	CPdpContext* iNewContext;
+	};
+
+
+class CNegotiateChannel : public CNegotiationBase
+	{
+	~CNegotiateChannel();
+public:
+	static CNegotiateChannel* New(CPdpContext* aContext, MQoSNegotiateEvent* aNotify);
+
+	virtual void Start();
+	virtual TBool Action(CPdpContext* aContext, const TContextParameters* aParams)
+		{return (this->*iActionList[iState].iAction)(aContext, aParams); }
+	virtual void Cancel(CPdpContext* aContext);
+
+protected:
+	CNegotiateChannel(CPdpContext* aContext, MQoSNegotiateEvent* aNotify);
+	void ConstructL();
+
+private:
+	static const SActionStep<CNegotiateChannel> iActionList[];
+	CPdpContext* iChannel;
+	};
+
+class CJoinRequest : public CRequestBase
+	{
+	~CJoinRequest();
+public:
+	static CJoinRequest* New(CPdpContext* aContext, CFlowData* aFlowData, MQoSNegotiateEvent* aNotify);
+
+	virtual void Start();
+	virtual TBool Action(CPdpContext* aContext, const TContextParameters* aParams)
+		{return (this->*iActionList[iState].iAction)(aContext, aParams); }
+
+	virtual void Failure(CPdpContext* aPdpContext, TInt aErrorCode);
+	virtual void Cancel(CPdpContext* aContext);
+
+protected:
+	CJoinRequest(CPdpContext* aContext, CFlowData* aFlowData, MQoSNegotiateEvent* aNotify);
+
+	TBool DoStartWithTargetContext(CPdpContext *, const TContextParameters*);
+
+
+private:
+	static const SActionStep<CJoinRequest> iActionList[];
+	CPdpContext* iChannel;
+	};
+
+class CLeaveRequest : public CRequestBase
+	{
+	~CLeaveRequest();
+public:
+	static CLeaveRequest* New(CPdpContext* aContext, CFlowData* aFlowData, MQoSNegotiateEvent* aNotify);
+
+	virtual void Start();
+	virtual TBool Action(CPdpContext* aContext, const TContextParameters* aParams)
+		{return (this->*iActionList[iState].iAction)(aContext, aParams); }
+
+	virtual void Failure(CPdpContext* aPdpContext, TInt aErrorCode);
+	virtual void Cancel(CPdpContext* aContext);
+
+protected:
+	CLeaveRequest(CPdpContext* aContext, CFlowData* aFlowData, MQoSNegotiateEvent* aNotify);
+	void ConstructL();
+
+private:
+	static const SActionStep<CLeaveRequest> iActionList[];
+	CPdpContext* iChannel;
+	};
+
+#endif