// 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__