// Copyright (c) 1999-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 EPOCSVR_H
#define EPOCSVR_H

#include <e32base.h>
#include <btdevice.h>
#include <bluetooth/eirpublisher.h>
#include "SDPDatabase.h"

class CSdpServSession;
class CSdpDatabaseSubSession;
class CSdpUuidManager;

/**
SDP Server Shutdown Timer.
Closes the SDP server after a preset delay. Activated before the first client connects
and after the last client disconnects.
**/
NONSHARABLE_CLASS(CSdpServerShutdown) : public CTimer
	{
	enum {KSdpServerShutdownDelay=5000000};	// approx 5s
public:
	inline CSdpServerShutdown();
	inline void ConstructL();
	inline void Start();
private:
	void RunL();
	};

_LIT(KSdpServerPanic,"SdpServInternal");
enum TSdpServerPanic
	{
	ESdpStoredAttrValNotEncoded = 0,
	ESdpAttributeEncodingFailed = 1,
	ESdpBadState = 2,
	ESdpReadAlreadyOutstanding = 3,
	ESdpOutstandingOperation = 4,
	};

void PanicServer(TSdpServerPanic aPanic);
void PanicClient(const RMessage2& aMessage, TSdpClientPanic aPanic);

/**
   The EPOC SDP Server.
   This is the start of the EPOC client/server
   class hierarchy
**/
NONSHARABLE_CLASS(CSdpServer) : public CPolicyServer
	{
public:
	//construct / destruct
	static CSdpServer* NewLC();
	CSdpDatabase* Database();
	void BuildRecordZeroL();
	~CSdpServer();

	void AddSession();
	void DropSession();

	inline CSdpListener& Listener() const;

	TInt RunError(TInt aError);
	
	//database operations
	CSdpServRecord* CreateServiceRecordL(const RMessage2& aMessage);
	CSdpServRecord* FindAndCheckServiceRecordForDeletion(const RMessage2& aMessage);
	void UpdateAttributeL(const RMessage2& aMessage);
	void DeleteAttribute(const RMessage2& aMessage);
	void DeleteServiceRecord(CSdpServRecord* aServiceRecord);
	
private:
	CSdpServer();
	void ConstructL();
	//open/close a session
	CSession2* NewSessionL(const TVersion &aVersion) const;
	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

	void CheckAllowedL(const RMessage2& aMessage, const CSdpServRecord& aRecord);
	TBool Allowed(const RMessage2& aMessage, const CSdpServRecord& aRecord);
	
	CSdpServRecord* FindRecordByHandle(const TSdpServRecordHandle aHandle);
	CSdpAttr* FindAttributeByID(CSdpServRecord& aRecord, const TSdpAttributeID aAttrId);

	void UpdateOrCreateAtributeL(CSdpServRecord& aRecord, TSdpAttributeID aAttrId, const TDesC8& aPtr);
	void DatabaseStateChange();

private:
	TInt iMaxSessionCount;
	TInt iSessionCount;

	CSdpServerShutdown		iShutdown;
	
	RSocketServ				iSocketServ;
	CSdpListener*			iSdpListener;
	CSdpDatabase*			iSdpDatabase;

	CSdpServRecord*			iRecZero;
	CSdpAttrValueUint*		iDbState;			// This value is used to update a state attribute whenever a record is 
												// added or removed to facilitate caching by remotes
	CAttrEncoderVisitor*	iEncoderVisitor;	// We maintain a pre-alloced encoder visitor so we can update 
												// attributes without having to allocate memory.
	RBuf8					iEncodeBuf;			// Used by the encoder to encode into
	CSdpUuidManager*		iUuidManager;
	};


/**
   SDP Server Session.
   General purpose session used to create functionally specific subsessions.
**/
NONSHARABLE_CLASS(CSdpServSession) : public CSession2
	{
private:
	enum TSubSessionType{ESdpAgent, ESdpDatabase}; /*however sdpagent is still 
												     part of esock and may never
													 be moved here*/

public:
	CSdpServSession(const RMessage2& aMessage);
	~CSdpServSession();

	void ServiceL(const RMessage2 &aMessage);

	//Create/delete subsession
	void NewSubSessionL(TSubSessionType aType, const RMessage2& aMessage);
	void CloseSubSession(const RMessage2& aMessage); //can't fail - can panic client

	//resource counting
	void NumResourcesL(const RMessage2& aMessage);
	TInt CountResources();

	CSdpServer& Server();
	void CreateL(const CServer2& aServer);

private:
	void ConstructL();
	void CreateL();

	void DeleteSubsession(TUint aHandle, const RMessage2& aMessage);
	void RemoveSessionRecords();
	
private:
	TUint iSubSessionCount;
	RPointerArray<CSdpServRecord> iSessionRecords;
	};


//**********************************
// CEirPublisherSdpUuidBase
//**********************************
/**
CEirPublisherSdpUuidBase provides base class for Sdp Uuid Eir Publisher.
**/
NONSHARABLE_CLASS(CEirPublisherSdpUuidBase) : public CBase, public MEirPublisherNotifier
	{
public:
	static CEirPublisherSdpUuidBase* NewL(CSdpUuidManager& aSdpUuidManager, TEirTag aTag);

	~CEirPublisherSdpUuidBase();
	void UpdateUuids(TInt aLength);

protected:
	CEirPublisherSdpUuidBase(CSdpUuidManager& aSdpUuidManager, TEirTag aTag);
	void ConstructL();

protected:
	CSdpUuidManager& iParent;
	CEirPublisher* iPublisher; 
	TEirTag iTag;
	};

//**********************************
// CEirPublisherSdpUuid16
//**********************************
/**
Provides functionality to publish 16 bit UUIDs to EIR.
**/
NONSHARABLE_CLASS(CEirPublisherSdpUuid16) : public CEirPublisherSdpUuidBase
	{
public:
	static CEirPublisherSdpUuid16* NewL(CSdpUuidManager& aSdpDatabase);
	~CEirPublisherSdpUuid16();

private:
	CEirPublisherSdpUuid16(CSdpUuidManager& aSdpDatabase);

	// From MEirPublisherNotifier
	void MepnSpaceAvailable(TUint aBytesAvailable);
	void MepnSetDataError(TInt aResult);

private:
	HBufC8* iExtracted;
	};

//**********************************
// CEirPublisherSdpUuid128
//**********************************
/**
Provides functionality to publish 128 bit UUIDs to EIR.
**/
NONSHARABLE_CLASS(CEirPublisherSdpUuid128) : public CEirPublisherSdpUuidBase
	{
public:
	static CEirPublisherSdpUuid128* NewL(CSdpUuidManager& aSdpDatabase);
	~CEirPublisherSdpUuid128();

private:
	CEirPublisherSdpUuid128(CSdpUuidManager& aSdpDatabase);

	// From MEirPublisherNotifier
	void MepnSpaceAvailable(TUint aBytesAvailable);
	void MepnSetDataError(TInt aResult);

private:
	HBufC8* iExtracted;
	};


//**********************************
// CSdpUuidManager
//**********************************
/**
Retrieve UUIDs from CSdpDatabase and then store them in 16 or 128 bit Eir Uuid PublishersUUIDs
**/
NONSHARABLE_CLASS(CSdpUuidManager) : public CBase
	{
public:
	static CSdpUuidManager* NewL(CSdpDatabase& aSdpDatabase);
	~CSdpUuidManager();
	
	void NotifySdpRecordChange();
	void AddUuid(TUUID aUuid);
	void ResetUuids();
	HBufC8* GetAll16BitUUIDs(TInt aBytesAvailable, TBool& aPartial);
	HBufC8* GetAll128BitUUIDs(TInt aBytesAvailable, TBool& aPartial);

private:
	CSdpUuidManager(CSdpDatabase& aSdpDatabase);
	void ConstructL();

private:
	CSdpDatabase& 				iSdpDatabase;
	CAttrUuidVisitor*			iUuidVisitor;
	CEirPublisherSdpUuid16* 	iEirPublisherSdpUuid16;
	CEirPublisherSdpUuid128*	iEirPublisherSdpUuid128;
	RUUIDContainer				i16BitUUIDs;
	RUUIDContainer				i128BitUUIDs;
	};

enum TSdpServerPanics
	{
	ESdpServerUuidFlattenBroken = 0,
	ESdpServerDeleteServiceRecordHandleZero = 1,
	ESdpServerUpdateAttributeRecordHandleZero = 2,
	ESdpServerDeleteAttributeRecordHandleZero = 3
	};
_LIT(KSdpServerPanicName, "SdpServer");

#endif