// 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:
// qoslib_glob.h - Qoslib global (TLS) data
// Qoslib global (TLS) data
//



/**
 @internalComponent
*/
#ifndef __QOSLIB_GLOB_H__
#define __QOSLIB_GLOB_H__

#include "qoslib.h"
#include "pfqosparser.h"
#include "pfqos_stream.h"
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <networking/qoslib_internal.h>
#endif

//
const TInt KQoSSignaledOK		= 0x0001; // Signaling ok
const TInt KQoSSignaledFailed	= 0x0002; // Signaling failed
const TInt KQoSProvisionedOK	= 0x0004; // Provisioning ok
const TInt KQoSProvisionedFailed	= 0x0008; // Provisioning failed
const TInt KQoSOK				= 0x0010; // A scheduler module should return this when ok 
const TInt KQoSFailed			= 0x0020; // A scheduler module should return this when request fails
const TInt KQoSRequestPending	= 0x0040; // Request is pending and the result will be given using 
										  // Event-method (see below)

const TInt KQoSDefaultBufSize = 8000;

// Forward declaration
class CQoSMan;
// 
class CQoSRequestBase : public CBase
{
	friend class CQoSMan;
public:
	~CQoSRequestBase();

	virtual void ProcessEvent(TPfqosMessage& aMsg)=0;
	virtual void NotifyError(TInt aReason)=0;
	virtual TBool MatchReply(const TPfqosMessage& aMsg, TUint8 aMsgType)=0;
	virtual void ProcessReply(TPfqosMessage& aMsg)=0;
	TInt NotifyEvent(MQoSObserver& aObserver, TUint aMask);
	TInt CancelNotifyEvent(MQoSObserver& aObserver);

protected:
	void ParseExtensions(TPfqosMessage& aMsg, CQoSParameters& aPolicy);
	TInt GetExtensionType(const TDesC8& aData, TInt& aType);

protected:
	TSglQueLink iNext;
	TUint iEventMask;
	MQoSObserver* iObserver;
	CQoSParameters iPolicy;
	CQoSMan* iManager;
};

class TSelectorItem : public TQoSSelector
{
public:
	TSglQueLink iNext;
};

enum EQoSChannelStatus
{
	EInit,
	EChannelCreated,
	EChannelReady
};


class CChannel : public CQoSRequestBase
{
public:
	enum TPendingStatus
	{
		ENone,
		EPendingOpen,
		EPendingOpenExisting,
		EPendingOpenExistingSetQoS,
		EPendingSetPolicy,
		EPendingJoin,
		EPendingLeave,
		EPendingDelete
	};

	static CChannel* NewL(CQoSMan* aManager, RSocket& aSocket, CQoSParameters* aSpec);
	~CChannel();
	void ProcessEvent(TPfqosMessage& aMsg);
	void ProcessReply(TPfqosMessage& aMsg);
	TBool Match(TInt aChannelId);
	TBool MatchReply(const TPfqosMessage& aMsg, TUint8 aMsgType);
	TInt OpenExisting();
	TInt SetQoS(CQoSParameters& aPolicy);
	TInt Join(RSocket& aSocket);
	TInt Leave(RSocket& aSocket);
	TInt GetCapabilities(TUint& aCapabilities);
	void NotifyError(TInt aReason);

	inline CQoSParameters& GetPolicy();
	inline TUint Capabilities() const;
	inline EQoSChannelStatus Status() const;
	inline TInt ChannelId() const;
	TInt Close();

private:
	CChannel(CQoSMan* aManager);
//	CChannel(CQoSMan* aManager, CQoSParameters* aSpec);
	void ConstructL(RSocket& aSocket, CQoSParameters* aSpec);
//	void ConstructL(RSocket& aSocket);
	void CreateSelector(TQoSSelector& aSelector, const TPfqosMessage& aMsg);

private:
	EQoSChannelStatus iStatus;
	TInt iChannelId;
	TQoSSelector iRequestSelector;
	TQoSSelector iPendingRequestSelector;
	TPendingStatus iPending;
	TUint iCapabilities;
};

class CPolicy : public CQoSRequestBase
{
public:
	enum TPendingStatus
	{
		ENone,
		EPendingAdd,
		EPendingUpdate,
		EPendingDelete,
		EPendingGet,
		EPendingLoadFile,
		EPendingUnloadFile
	};

	static CPolicy* NewL(CQoSMan* aManager, const TQoSSelector& aSelector);
	~CPolicy();
	void SetQoSL(CQoSParameters& aPolicy);
	void GetQoSL();
	void DeleteL();
	void LoadFileL(const TDesC& aName);
	void UnloadFileL(const TDesC& aName);
	TBool Match(const TQoSSelector& aSelector);
	void ProcessReply(TPfqosMessage& aMsg);
	TBool MatchReply(const TPfqosMessage& aMsg, TUint8 aMsgType);
	void ProcessEvent(TPfqosMessage& aMsg);
	void NotifyError(TInt aReason);
	void Close();

protected:
	CPolicy(CQoSMan* aManager, const TQoSSelector& aSelector);

private:
	TPendingStatus iPending;
	TBool iPolicyCreated;
	TQoSSelector iSelector;
	TUint iCapabilities;
};

//
class CRequest : public CBase
{
public:
	static CRequest* NewL(CQoSRequestBase* aOwner, TUint aBufSize);
	~CRequest();

protected:
	CRequest(CQoSRequestBase* aOwner);
	void ConstructL(TUint aBufSize);

public:
	CPfqosStream* iMsg;
	CQoSRequestBase* iOwner;
	TSglQueLink iLink;
};

class CSender;
class CQoSMan : public CActive
{
public:
	static CQoSMan* NewL(TInt aPriority=0);
	~CQoSMan();
	
	// qos channel methods
	CChannel* OpenQoSChannelL(RSocket& aSocket);
	void RemoveQoSChannel(CChannel* aChannel);
	void SetQoSL(CChannel& aChannel);
	void CreateL(CChannel& aChannel, const TQoSSelector& aSelector);
	void OpenExistingL(CChannel& aChannel, const TQoSSelector& aSelector);
	void JoinL(CChannel& aChannel, const TQoSSelector& aSelector);
	void LeaveL(CChannel& aChannel, const TQoSSelector& aSelector);

	// qos policy methods
	CPolicy* OpenQoSPolicyL(const TQoSSelector& aSelector);
	void RemoveQoSPolicy(CPolicy* aChannel);
	CPolicy* FindPolicy(const TQoSSelector& aSelector);

	void ClearPendingRequest(CQoSRequestBase* aRequest);
	void Send(CRequest* aRequest);
	inline RSocket& Socket();
	inline const TCheckedUid& Uid() const;
	inline void Open();
	void Close();

protected:
	CQoSMan(TInt aPriority=0);
	void ConstructL();

private:
	void Notify(TPfqosMessage& aMsg);
	void Flush();
	CChannel* Match(TPfqosMessage& aMsg);
	CChannel* MatchChannelReply(TPfqosMessage& aMsg, TUint8 aMsgType);
	CPolicy* MatchPolicyReply(TPfqosMessage& aMsg, TUint8 aMsgType);
	void ExecEvent(TPfqosMessage& aMsg);
	void ExecReply(TPfqosMessage& aMsg);
	void RunL();
	void DoCancel();

private:
	TInt iRefCount;
	TBool iNotifyPending;
	TBool iShutdown;
	TPtr8 iRecBuf;
	HBufC8* iBuf;
	RSocketServ iSocketServer;
	RSocket iSocket;
	CSender* iSender;
	TCheckedUid iUid;
	TSglQue<CChannel> iChannels;
	TSglQue<CPolicy> iStaticPolicies;
};

//
class QoSManGlobals
	{
public:
	inline static CQoSMan* Get();
	inline static void Set(CQoSMan* aGlobals);
	};

#include "qoslib_glob.inl"

#endif