// Copyright (c) 1997-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 __LOADMANAGER_H__

 #define __LOADMANAGER_H__

 #include <e32base.h>

 #include <ecom/extendedinterfaceimplementationproxy.h>

 //Forward declarations

 class CUnloadPolicy;

 /**

 @internalComponent

 Represents an instance of an implementation

 */

 NONSHARABLE_CLASS(CInstanceInfo): public CBase

 	{

 public:

 	virtual ~CInstanceInfo();

 	CUnloadPolicy* UnloadPolicy() {return iUnloadPolicy;};

 public:

 	virtual TUid ImplementationUid() = 0;

     virtual TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() = 0;

     virtual TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() = 0;

     virtual TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID) = 0;

     virtual void DestroyExtObject(const TUid& aExtendedInterfaceUID) = 0;

     virtual TAny* ImplementationObject() = 0;

 protected:

     CInstanceInfo(CUnloadPolicy* aUnloadPolicy);

 private:

    	// The Unload Policy for the dll which contains this implementation

 	CUnloadPolicy*	iUnloadPolicy;

 	};

 /**

 @internalComponent

 Represents an instance of a PLUGIN3 type implementation

 */

 NONSHARABLE_CLASS(CInstanceInfoExtended): public CInstanceInfo

 {

 public:

 	static CInstanceInfoExtended* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aRow);

 	void SetObject(TAny* aImplementationObject);

 	~CInstanceInfoExtended(); // Release all extended objects (if not already released)

 public:

     TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};

     TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() {return iImplementationProxyRow->iFuncPtrInterfaceGetL;};

     TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() {return iImplementationProxyRow->iFuncPtrInterfaceRelease;};

     TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID);

     void DestroyExtObject(const TUid& aExtendedInterfaceUID);

     TAny* ImplementationObject() {return iImplementationObject;};

 private:

 	CInstanceInfoExtended(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aImplementationProxyRow);

 private:

    // Pointer to proxy implementation table row entry that this instance corresponds to.

    // This is where the implementation UID, get and release extended interface function

    // pointers reside.

    const TImplementationProxy3* iImplementationProxyRow;

    // The instantiation interface object for the dll which contains this implementation

    TAny*	iImplementationObject;

    // The created extended object information structure.

    struct TExtendedObjectInfo

 	   {

 	   // The extended interface UID

        TUid    iExtendedInterfaceUID;

 	   // The extended interface object for the this implementation

 	   TAny*   iExtendedInterfaceObject;

 	   };

     // List of all of the created extended objects for this implementation

 	RArray<TExtendedObjectInfo> iExtendedObjectInfo;

 	// Friend classes

 	friend class TLoadManager_StateAccessor;

 };

 /**

 @internalComponent

 Represents an instance of a PLUGIN1 type implementation

 */

 NONSHARABLE_CLASS(CInstanceInfoSimple): public CInstanceInfo

 {

 public:

 	static CInstanceInfoSimple* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);

 public:

     TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};

 	// The following functions are not required for CInstanceInfoSimple.

 	// PLUGIN1 type is not meant to extend interfaces.  	

   	TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr(){return NULL;};

  	TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr(){return NULL;};

  	TAny* CreateExtObjectL(const TUid& /*aExtendedInterfaceUID*/) {return NULL;};

  	void DestroyExtObject(const TUid& /* aExtendedInterfaceUID*/) {};

 	TAny* ImplementationObject() {return NULL;}; 

 private:

 	CInstanceInfoSimple(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);

 private:

    // Pointer to proxy implementation table row entry that this instance corresponds to.

    // This is where the implementation UID resides.

    const TImplementationProxy* iImplementationProxyRow;

 };

 /**

 @internalComponent

 Manages the loading and unloading of interface implementation groupings.

 */

 NONSHARABLE_CLASS(CLoadManager) : public CBase

 {

 public:

 	static CLoadManager* NewL();

 	~CLoadManager();

 	TBool DestroyedThis(TUid aInstanceKey);

 	TBool PolicyArraysEmpty() const ;

 	TAny* ImplementationObjectL(const TUid& aUniqueImplementationUid,

 							   const TEntry& aEntry,

 							   TAny* aCreationParameters,

 							   TBool aCreationParamsFlag,

 							   TUid& aInstanceKey);

 	TAny* GetExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);

 	void ManuallyReleaseExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);

 	void ClearGarbage();

 	TUid GetImplementationUidL(TUid aInstanceKey);

 private:

 	CLoadManager();

 	void GetUnloadPolicy(TUid aUniqueImplementationUid,

 						 const TEntry& aEntry,

 						 CUnloadPolicy*& aPolicy);

 	template<typename TImpProxy,typename T> TAny* GetNewLPointerAndProxyTableRowL(TUid aUniqueImplementationUid,

 										 TImpProxy*& aImplementationTableEntry,

 										 const T aProxy);

 	TAny* ImplementationObject1L(const TUid& aUniqueImplementationUid,

 						   	     TAny* aCreationParameters,

 								 TBool aCreationParamsFlag,

 								 TUid& aInstanceKey,

 								 CUnloadPolicy* aPolicy,

 								 TLibraryFunction& aLibFunctionProxy);

 	TAny* ImplementationObject3L(const TUid& aUniqueImplementationUid,

 						   	     TAny* aCreationParameters,

 								 TBool aCreationParamsFlag,

 								 TUid& aInstanceKey,

 								 CUnloadPolicy* aPolicy,

 								 TLibraryFunction& aLibFunctionProxy);

 	TAny* ImplementationObjectL(TAny* aCreationParameters,

 								TBool aCreationParamsFlag,

 								const TAny* aNewLpointer);

 	void CleanupAfterFailure(CUnloadPolicy* aPolicy);

 	void Cleanup(CUnloadPolicy* aPolicy);

 private:

 #ifdef ECOM_TRACE

 	/** Instantiation counter for debug trace */

 	TInt iDebugInstantiationCounter;

 #endif

 	/** List of all the UnloadPolicies for objects which have been created */

 	RPointerArray<CUnloadPolicy> iAllUnloadPolicies;

 	/** Garbage UnloadPolicy which is not in use anymore */

 	CUnloadPolicy* iGarbagePolicy;

 	// Array of instance information

 	RPointerArray<CInstanceInfo> iInstanceInfoList;

 	// Make the test State Accessor a friend

 	friend class TLoadManager_StateAccessor;

 };

 #include "loadmanager.inl"

 #endif //__LOADMANAGER_H__