// Copyright (c) 2006-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:
//



/**
 @internalComponent
*/
#ifndef __MODULES_H__
#define __MODULES_H__

#include <e32std.h>
#include <e32base.h>

#include "timeout.h"	// ...because inline StartWatchDog needs Start() from CModuleTimeout

class CInterface;
class CModuleManager;
class CProtocolQoS;
class CModuleSpec;

// module data
class CModuleData : public CBase
	{
	friend class CModuleManager;
private:
	// CModuleData is "almost reference counted object". When the iRefCount==0, the
	// object is only present in CModuleManagers iModuleList (and a watchdog timer
	// is running for it's destruction. Delete can only be issued by self or by
	// CModuleManager.
	~CModuleData();
public:
	static CModuleData* NewLC(const TDesC& aModuleName, TUint aProtocolId, TUint aTimeoutDelay, TDblQue<CModuleData>& aList);
	inline void Open();
	void Close();
	inline CModuleBase* Module();
	inline void StartWatchDog();

public:
	CModuleBase* iModule;
	CProtocolFamilyBase* iFamily;
	TUint iProtocolId;
	TInt iRefCount;
	TUint iFlags;
	RLibrary iLib;
#ifdef _LOG
	TProtocolName iName; // Store the module name for easy debugging.
#endif

protected:
	CModuleData(TUint aProtocolId, TUint aTimeoutDelay);
	void ConstructL(const TDesC& aModuleName);

private:
	static TInt WatchDogCallBack(TAny* aProvider);
	CModuleTimeout *iTimeout;	//?? only used for "shutdown watchdog" -- could try to avoid need of this?
	TUint iTimeoutDelay;
	TDblQueLink iLink;
	};

// inline methods
inline void CModuleData::Open()
	{ iRefCount++; };

inline CModuleBase* CModuleData::Module()
	{ return iModule; };

inline void CModuleData::StartWatchDog()
	{ iTimeout->Start(iTimeoutDelay); };


class RModule;

// library loader
class CModuleManager : public CBase
	{
public:
	static CModuleManager* NewL(CProtocolQoS& aProtocol);
	~CModuleManager();

	RModule* LoadModuleL(CModuleSpec& aModuleSpec, CProtocolBase* aProtocol);
	RModule* LoadModuleL(CProtocolBase* aProtocol, const TDesC& aModuleName, TUint aProtocolId, CExtension* aData = NULL);
	RModule* OpenModuleL(TUint aProtocolId);
	TBool IsLoaded(TUint aProtocolId);
	void Unbind(CProtocolBase* aProtocol, TInt aId);

protected:
	CModuleManager(CProtocolQoS& aProtocol);

private:
	CModuleData* Lookup(TUint aProtocolId);
	inline CProtocolQoS& Protocol();
private:
	CProtocolQoS& iProtocol;
	TDblQue<CModuleData> iModuleList;
	};
	
// inline methods
inline CProtocolQoS& CModuleManager::Protocol()
	{ return iProtocol; }


// A handle to CModuleBase. CFlowHook keeps a list of RModules
class RModule
	{
public:
	RModule(CModuleData& aModuleData);
	RModule(const RModule& aModule);
	~RModule();
	inline CModuleBase* Module();
	inline TUint Flags() const;
	inline TUint ProtocolId() const;
#ifdef _LOG
	inline const TDesC& Name() const;
#endif
private:
	CModuleData& iModuleData;
	};

// inline methods
inline CModuleBase* RModule::Module()
	{ return iModuleData.Module(); };

inline TUint RModule::Flags() const
	{ return iModuleData.iFlags; };

inline TUint RModule::ProtocolId() const
	{ return iModuleData.iProtocolId; };

#ifdef _LOG
inline  const TDesC& RModule::Name() const
	{ return iModuleData.iName; }
#endif

#endif