FCL/sf/os/ossrv: comparison lowlevellibsandfws/pluginfw/Framework/frame/EComSession.cpp

equal deleted inserted replaced

--1:000000000000
+:e4d67989cc36
+// 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:
+// The Implementation of the REComSession singleton class which
+// maintains the connection to ECom framework services.
+// Include Files
+//
+//
+/**
+@internalComponent
+@file
+*/
+#include <s32mem.h>
+#include "EComDebug.h"
+#include <ecom/ecom.h>
+#include "LoadManager.h"
+#include "TlsData.h"
+#include "EComServerStart.h"
+#include "EComMessageIds.h"
+//patchable constant defining the default size of buffer used during ListImplementations
+#include "EComPatchData.h"
+#include "EComUidCodes.h"
+//
+// Forward declarations
+//
+// Global Constants
+// The maximum number of attempts the client should make to
+// start up the server.
+const TInt KMaxStartAttempts = 2;
+// The buffer for passing the extended interface list. Each extended interface
+// takes up 4 bytes. Currently the maximum extended interface is 8. By setting to the maximum,
+// the KErrOverFlow should not happen during the request of ListExtendedInterfacesL.
+const TInt KListExtendedInterfaceBufferSize = 32;
+//
+// Functions & Methods
+static void CleanupFinalClose(TAny* /*aPtr*/)
+	{
+	REComSession::FinalClose();
+	}
+static void ResetAndDestroyArray(TAny* aPtr)
+	{
+	(static_cast<RImplInfoPtrArray*>(aPtr))->ResetAndDestroy();
+	}
+static void ResetArray(TAny* aPtr)
+	{
+	(static_cast<RExtendedInterfacesArray*>(aPtr))->Reset();
+	}
+// Start the server process/thread which lives in an EPOCEXE object
+//
+static TInt StartServer()
+	{
+	const TUidType serverUid(KNullUid,KNullUid,KEComServerUid3);
+	//
+	//
+	// EPOC is easy, we just create a new server process. Simultaneous launching
+	// of two such processes should be detected when the second one attempts to
+	// create the server object, failing with KErrAlreadyExists.
+	//
+	RProcess server;
+	TInt error = server.Create(KEComServerImg,KNullDesC,serverUid);
+	if (error != KErrNone)
+		{
+		return error;
+		}
+	TRequestStatus stat;
+	server.Rendezvous(stat);
+	if (stat!=KRequestPending)
+		server.Kill(0);		// abort startup
+	else
+		server.Resume();	// logon OK - start the server
+	User::WaitForRequest(stat);		// wait for start or death
+	// we can't use the 'exit reason' if the server panicked as this
+	// is the panic 'reason' and may be '0' which cannot be distinguished
+	// from KErrNone
+	error=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
+	server.Close();
+	return error;
+	}
+EXPORT_C REComSession::REComSession() :
+	iReserved1(0),
+	iReserved2(0)
+	{
+	}
+/**
+This method returns a reference to the singleton client/server session object
+maintained by the ECOM client library, referenced counted. If it does
+not exist it is initialised and then returned. Clients should store the handle
+returned by refernce or by pointer. Storage by value is highly discouraged.
+It is only necessary to use the Open()/Close() API directly if you need access
+to the notification methods. Access to the static API does not require these
+to be used. Please remeber each call to Open() must have an equivalent Close().
+@return	Reference to the open singleton session
+@leave  KErrNoMemory
+@leave  One of the system-wide error codes
+@post REComSession is connected and ready to issue ECOM requests.
+*/
+EXPORT_C REComSession& REComSession::OpenL()
+	{
+	//CGlobalData::NewL() will create just one CGlobalData instance.
+	//Every next CGlobalData::NewL() call will return a pointer to the already created
+	//CGlobalData instance.
+	CGlobalData* globalData = CGlobalData::NewL();
+	globalData->IncRefCnt();
+	return globalData->EComSession();
+	}
+/**
+This method returns a reference to the singleton client/server session object
+maintained by the ECOM client library, referenced counted. If it does
+not exist it is initialised and then returned.
+@return	Reference to the open singleton session which is on the cleanupstack
+@leave  KErrNoMemory
+@leave  One of the system-wide error codes
+@post REComSession is connected and ready to issue ECOM requests.
+*/
+REComSession& REComSession::OpenLC()
+	{
+	REComSession& ecomSession = REComSession::OpenL();
+	CleanupClosePushL(ecomSession);
+	return ecomSession;
+	}
+/**
+Initialisation phase of two phase construction.
+@leave  One of the system-wide error codes
+@post  REComSession is fully initialised.
+*/
+void REComSession::ConstructL()
+	{
+	// Now connect to the ECom server
+	TInt retry=KMaxStartAttempts;
+	for (;;)
+		{
+		// create session with unlimited message slots due to  notification API being asynchronous
+		TInt error = CreateSession(KEComServerName,TVersion(KEComServerMajorVN,KEComServerMinorVN,KEComServerBuildVN),-1);
+		if(error == KErrNone)
+			{
+			return;	// Success
+			}
+		else if (error != KErrNotFound && error != KErrServerTerminated)
+			User::Leave(error);
+		if (--retry==0)
+			User::Leave(error);
+		error = StartServer();
+		if (error != KErrNone && error != KErrAlreadyExists)
+			User::Leave(error);
+		}
+	}
+/**
+Closes the open handle on the ECOM framework.
+Reference count is decremented and the ECOM client/server session is closed.
+@pre  REComSession must have been opened.
+@post REComSession reference count is decremented, server session closed
+*/
+EXPORT_C void REComSession::Close()
+	{
+	// Switch close protection flag
+	CGlobalData* globalData = CGlobalData::Instance();
+	if(globalData)
+		{
+		//Decrement the reference count. Do not destroy the object. It will be used in FinalClose().
+		globalData->DecRefCnt();
+		}
+	else
+		{
+		ReallyClose();
+		}
+	}
+/**
+The method will close the ECOM session connection.
+@pre  REComSession must have been opened
+@post The session is closed
+*/
+void REComSession::ReallyClose()
+	{
+	// Now disconnect from the ECom server
+	RSessionBase::Close();
+	}
+/**
+This method is used in processes that have utilised the ECOM framework, it
+does nothing if the ECOM framework has not been initialised. Its main purpose
+is to release memory and close handles held on unused plug-in implementations
+and their associated DLLs. If is found (through reference counting) that the
+ECOM framework is no longer in use in the calling thread the session to the
+ECOM's server is also closed.
+This method is called by direct users of the ECOM framework wherever possible
+(e.g. library, server or test code). It is safe to call it at any time outside
+of plug-in code as the user's scenario dictates. This maybe during a test case
+or just before process termination.
+Note: It must never be called from within a plug-in implementations class
+destructor, especially following a DestroyImplementation() as there is a risk
+that the plug-in's supporting DLL may immediately be unloaded by the Kernel due
+to the closure of RLibrary handles. It can result in a KERN-EXEC if the
+destructor call stack is still inside the DLL that is unloaded.
+Note: Processes that utilise the ECOM framework that do not use this call
+are at risk of a UHEAP_MARKEND generated panic in debug builds.
+*/
+EXPORT_C void REComSession::FinalClose()
+	{
+	CGlobalData* globalData = CGlobalData::Instance();
+	if(globalData)
+		{
+		// Clear out any garbage unload policies that may exist in the LoadManager.
+		globalData->LoadManager().ClearGarbage();
+		// With ref count greater than 0 indicates there is still open session
+		// within this thread, otherwise clean up
+		if(globalData->RefCnt() <= 0)
+			{
+			__ASSERT_DEBUG(globalData->LoadManager().PolicyArraysEmpty(), User::Invariant());
+			delete globalData;
+			}
+		}
+	}
+/**
+Registers for notification messages when the underlying ECOM registration
+data changes.
+The client must not call this api again until their request is Completed
+as this could result in a 'stray signal'.
+This api should be placed first in the RunL of an Active Object otherwise
+changes could be lost.
+RunError should be implemented to cater for any Leaves.
+For example, it could retry after a second if the ECom server is busy rebuilding its
+indexes.
+CancelNotifyOnChange should be called to cancel this request and should NOT be
+part of the RunL.
+@param			aStatus A request status object to complete for notification signalling.
+@pre 			REComSession must have been opened.
+@post			The caller is registered for receipt of notifications
+				if the server's registry data changes.
+*/
+EXPORT_C void REComSession::NotifyOnChange(TRequestStatus& aStatus)
+	{
+	aStatus=KRequestPending;
+	SendReceive(ENotifyOnChange,TIpcArgs(&aStatus), aStatus);
+	}
+/**
+De-registers for notification messages.
+@param			aStatus The request status object originally passed
+				to NotifyOnChange() for notification signalling.
+@pre 			REComSession must have been opened.
+@post			The caller's registeration for reciept of notifications
+				of registry data changes has been cancelled.
+*/
+EXPORT_C void REComSession::CancelNotifyOnChange(TRequestStatus& aStatus)
+	{
+	if (aStatus!=KRequestPending)
+		return;
+	SendReceive(ECancelNotifyOnChange,TIpcArgs(&aStatus));
+	}
+// ___________________________________________________________________________
+// Message passing methods
+//ListImplementationsL - LI1
+/**
+Retrieves a list of all the implementations which satisfy the specified interface.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	ListImplementationsL(aInterfaceUid,extendedInterfaces,aImplInfoArray);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//ListImplementationsL - LI2
+/**
+Retrieves a list of all the implementations which
+satisfy the specified interface with selection restriction to
+the specified parameters.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@since			7.0
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  const TEComResolverParams& aResolutionParameters,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	ListImplementationsL(aInterfaceUid,extendedInterfaces,aResolutionParameters,aImplInfoArray);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//ListImplementationsL - LI3
+/**
+Retrieves a list of all the implementations which satisfy the
+specified interface with selection restriction to
+the specified parameters.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+Overload with a client provided CResolver.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The CResolver UID which identifies the resolver
+				implementation with the required client defined behaviour.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  const TEComResolverParams& aResolutionParameters,
+												  TUid aResolverUid,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	ListImplementationsL(aInterfaceUid,extendedInterfaces,aResolutionParameters,aResolverUid,aImplInfoArray);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//ListImplementationsL - LI4
+/**
+Retrieves a list of all the implementations which satisfy the specified interface, extended Interfaces.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or many extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@publishedPartner
+@released
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  RExtendedInterfacesArray& aExtendedInterfaces,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	if( aInterfaceUid.iUid == 0 )
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	TEComResolverParams resolutionParameters;
+	ecomSession.ListImplementationsL(EListImplementations,
+						 aInterfaceUid,
+						 aExtendedInterfaces,
+						 resolutionParameters,
+						 KNullUid,
+						 aImplInfoArray);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	}
+//ListImplementationsL - LI5
+/**
+Retrieves a list of all the implementations which
+satisfy the specified interface, extended interfaces, with selection restriction to
+the specified parameters.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  RExtendedInterfacesArray& aExtendedInterfaces,
+												  const TEComResolverParams& aResolutionParameters,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	if( aInterfaceUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	ecomSession.ListImplementationsL(EListResolvedImplementations,
+						 aInterfaceUid,
+						 aExtendedInterfaces,
+						 aResolutionParameters,
+						 KNullUid,
+						 aImplInfoArray);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	}
+//ListImplementationsL - LI6
+/**
+Retrieves a list of all the implementations which satisfy the
+specified interface, extended Interfaces, with selection restriction to
+the specified parameters.
+The aImplInfoArray on exit contains the plug-in implementations who's plug-in
+DLLs have sufficient capabilities to be loaded by the calling client process.
+Overload with a client provided CResolver.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The CResolver UID which identifies the resolver
+				implementation with the required client defined behaviour.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  RExtendedInterfacesArray& aExtendedInterfaces,
+												  const TEComResolverParams& aResolutionParameters,
+												  TUid aResolverUid,
+												  RImplInfoPtrArray& aImplInfoArray)
+	{
+	if( aInterfaceUid.iUid == 0 ||
+		aResolverUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	ecomSession.ListImplementationsL(EListCustomResolvedImplementations,
+						 aInterfaceUid,
+						 aExtendedInterfaces,
+						 aResolutionParameters,
+						 aResolverUid,
+						 aImplInfoArray);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	}
+//ListImplementationsL - LI7
+/**
+Retrieves a list of all the implementations which satisfy the specified interface.
+This method does not do capability check.
+The aImplInfoArray on exit contains the plug-in implementations .
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@param			aCapabilityCheck A boolean value EFalse , if no capability check is required ETrue otherwise.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  RImplInfoPtrArray& aImplInfoArray,TBool aCapabilityCheck)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	if( aInterfaceUid.iUid == 0 )
+	User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+													// using the global instance which is returned.
+	TEComResolverParams resolutionParameters;
+	ecomSession.ListImplementationsL(EListImplementations,
+						 aInterfaceUid,
+						 extendedInterfaces,
+						 resolutionParameters,
+						 KNullUid,
+						 aImplInfoArray,
+						 aCapabilityCheck);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//ListImplementationsL - LI8
+/**
+Retrieves a list of all the implementations which
+satisfy the specified interface with selection restriction to
+the specified parameters.This method does not do capability check.
+The aImplInfoArray on exit contains the plug-in implementations .
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@since			7.0
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+				@param			aCapabilityCheck A boolean value EFalse , if no capability check is required ETrue otherwise.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  const TEComResolverParams& aResolutionParameters,
+												  RImplInfoPtrArray& aImplInfoArray,TBool aCapabilityCheck)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	if( aInterfaceUid.iUid == 0)
+	User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	ecomSession.ListImplementationsL(EListResolvedImplementations,
+						 aInterfaceUid,
+						 extendedInterfaces,
+						 aResolutionParameters,
+						 KNullUid,
+						 aImplInfoArray,
+						 aCapabilityCheck);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//ListImplementationsL - LI9
+/**
+Retrieves a list of all the implementations which satisfy the
+specified interface with selection restriction to
+the specified parameters.This method does not do capability check.
+The aImplInfoArray on exit contains the plug-in implementations .
+Overload with a client provided CResolver.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The CResolver UID which identifies the resolver
+				implementation with the required client defined behaviour.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+				@param			aCapabilityCheck A boolean value EFalse , if no capability check is required ETrue otherwise.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+*/
+EXPORT_C void REComSession::ListImplementationsL(TUid aInterfaceUid,
+												  const TEComResolverParams& aResolutionParameters,
+												  TUid aResolverUid,
+												  RImplInfoPtrArray& aImplInfoArray,TBool aCapabilityCheck)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	if( aInterfaceUid.iUid == 0 ||
+	aResolverUid.iUid == 0)
+	User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	ecomSession.ListImplementationsL(EListCustomResolvedImplementations,
+						 aInterfaceUid,
+						 extendedInterfaces,
+						 aResolutionParameters,
+						 aResolverUid,
+						 aImplInfoArray,
+						 aCapabilityCheck);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	}
+//CreateImplementationL - CI1
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aImplementationUid A UID specifying the required interface implementation.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aImplementationUid,
+													TUid& aInstanceKey)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = EFalse;
+	if( aImplementationUid.iUid == 0 )
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	// Use the default resolver in the overloaded method.
+	TAny* result = ecomSession.ResolveAndCreateImplL(aImplementationUid, tempInstanceKey, NULL, instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI2
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aImplementationUid A UID specifying the required interface implementation.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aImplementationUid,
+													TInt32 aKeyOffset)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(aImplementationUid, key);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI3
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aImplementationUid A UID specifying the required interface implementation.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aImplementationUid,
+													TUid& aInstanceKey,
+													TAny* aInstantiationParams)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = ETrue;
+	if( aImplementationUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	// Use the default resolver in the overloaded method.
+	TAny* result = ecomSession.ResolveAndCreateImplL(aImplementationUid, tempInstanceKey, aInstantiationParams, instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI4
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aImplementationUid A UID specifying the required interface implementation.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aImplementationUid,
+													TInt32 aKeyOffset,
+													TAny* aInstantiationParams)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(aImplementationUid, key, aInstantiationParams);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI5
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TUid& aInstanceKey,
+													const TEComResolverParams& aResolutionParameters)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = EFalse;
+	if( aInterfaceUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+	// Use the default resolver in the overloaded method.
+	TAny* result = ecomSession.ResolveAndCreateImplL(aInterfaceUid, aResolutionParameters, tempInstanceKey, NULL,instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI6
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TInt32 aKeyOffset,
+													const TEComResolverParams& aResolutionParameters)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											key,
+											aResolutionParameters);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI7
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TUid& aInstanceKey,
+													TAny* aInstantiationParams,
+													const TEComResolverParams& aResolutionParameters)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	TAny* instance = CreateImplementationL(aInterfaceUid,
+						  				 extendedInterfaces,
+						  				 aInstanceKey,
+						  				 aResolutionParameters,
+						  				 aInstantiationParams);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	return instance;
+	}
+//CreateImplementationL - CI8
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TInt32 aKeyOffset,
+													TAny* aInstantiationParams,
+													const TEComResolverParams& aResolutionParameters)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											key,
+											aInstantiationParams,
+											aResolutionParameters);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI9
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TUid& aInstanceKey,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = EFalse;
+	if( aInterfaceUid.iUid == 0 ||
+		aResolverUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	// Use the default resolver in the overloaded method.
+	TAny* result = ecomSession.ResolveAndCreateImplL(aInterfaceUid, aResolutionParameters, aResolverUid, tempInstanceKey, NULL,instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI10
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TInt32 aKeyOffset,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											key,
+											aResolutionParameters,
+											aResolverUid);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI11
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TUid& aInstanceKey,
+													TAny* aInstantiationParams,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	TAny* instance = CreateImplementationL(aInterfaceUid,
+										   extendedInterfaces,
+										   aInstanceKey,
+										   aResolutionParameters,
+										   aResolverUid,
+										   aInstantiationParams);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	return instance;
+	}
+//CreateImplementationL - CI12
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													TInt32 aKeyOffset,
+													TAny* aInstantiationParams,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											key,
+											aInstantiationParams,
+											aResolutionParameters,
+											aResolverUid);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI13
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface implementation.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+				Default value is NULL.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+														const RExtendedInterfacesArray& aExtendedInterfaces,
+														TUid& aInstanceKey,
+														const TEComResolverParams& aResolutionParameters,
+														TAny* aInstantiationParams)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = ETrue;
+	if( aInterfaceUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	// Use the default resolver in the overloaded method.
+	TAny* result = ecomSession.ResolveAndCreateImplL(aInterfaceUid, aExtendedInterfaces, aResolutionParameters, tempInstanceKey, aInstantiationParams, instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI14
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface implementation.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+				Default value is NULL.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													const RExtendedInterfacesArray& aExtendedInterfaces,
+													TInt32 aKeyOffset,
+													const TEComResolverParams& aResolutionParameters,
+													TAny* aInstantiationParams)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											aExtendedInterfaces,
+											key,
+											aResolutionParameters,
+											aInstantiationParams);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+//CreateImplementationL - CI15
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface implementation.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aInstanceKey A 32-bit instance key that is returned by the ECom framework.
+				This instance key should be passed as an argument to the DestroyedImplementation()
+				method to identify the implementation for destruction.
+				No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+				Default value is NULL.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													const RExtendedInterfacesArray& aExtendedInterfaces,
+													TUid& aInstanceKey,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid,
+													TAny* aInstantiationParams)
+	{
+	TUid tempInstanceKey = aInstanceKey = KNullUid;
+	TBool instParamsFlag = ETrue;
+	if( aInterfaceUid.iUid == 0 ||
+		aResolverUid.iUid == 0)
+		User::Leave(KErrArgument);
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	// Use the custom resolver with specific aResolverUid in the overloaded method
+	TAny* result = ecomSession.ResolveAndCreateImplL(aInterfaceUid,
+													 aExtendedInterfaces,
+													 aResolutionParameters,
+													 aResolverUid,
+													 tempInstanceKey,
+													 aInstantiationParams,
+													 instParamsFlag);
+	CleanupStack::Pop(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	aInstanceKey = tempInstanceKey;
+	return result;
+	}
+//CreateImplementationL - CI16
+/**
+Instantiates an interface implementation to satisfy the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrArgument
+@leave			KErrPermissionDenied. This leave error can happen under the following conditions:
+				1. There is a capability mismatch between the process creating the implementation
+				 and the DLL containing the implementation
+				2. The plugin DLL installed on the media card was not properly installed,
+				either the system hash value of this plugin is missing or it is inconsistent
+				with that calculated for the plugin DLL at load time.
+@leave 			Or any of the System Wide error codes
+@param			aInterfaceUid A UID specifying the required interface implementation.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aKeyOffset An offset to the 32 bit identifer returned by the ECom framework to
+				identify this instance to the framework.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@param			aInstantiationParams The parameter structure to pass to the object creation method.
+				Default value is NULL.
+@return			TAny* A pointer to the instantiated interface implementation.
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+@publishedPartner
+@released
+*/
+EXPORT_C TAny* REComSession::CreateImplementationL(TUid aInterfaceUid,
+													const RExtendedInterfacesArray& aExtendedInterfaces,
+													TInt32 aKeyOffset,
+													const TEComResolverParams& aResolutionParameters,
+													TUid aResolverUid,
+													TAny* aInstantiationParams)
+	{
+	TUid key;
+	// Get the instance using the overload which gives us the key back
+	TAny* instance = CreateImplementationL(	aInterfaceUid,
+											aExtendedInterfaces,
+											key,
+											aResolutionParameters,
+											aResolverUid,
+											aInstantiationParams);
+	// Find the key location using the offset and store it
+	TUint8* offsetPtr = REINTERPRET_CAST(TUint8*, instance) + aKeyOffset;
+	TUid* instanceKey = REINTERPRET_CAST(TUid*, offsetPtr);
+	*instanceKey = key;
+	return instance;
+	}
+/**
+Returns the requested interface, NULL if it does not exist
+@leave			KErrNotFound When the supplied 32-bit implementation instance key is not recognised by ECom.
+@leave			KErrArgument When a null implementation instance key is passed as an argument to ECom.
+@leave			Any of the other System wide errors
+@param			aInstanceKey A 32-bit implementation instance key that is returned from a call to one of the CreateImplementationL()
+				methods. ECOM uses this implementation instance key when it is passed as an argument to the
+				DestroyedImplementation() method to identify an implementation for destruction. No meaning should be attached to
+				this implementation instance key by ECOM clients and it should not be used for any other purpose.
+@param			aExtendedInterfaceUid Identifies an interface to fetch from the plug-in instance.
+@return			TAny* A pointer to the extended interface implementation if the implementation identified by aInstanceKey
+supports it, or NULL if the implementation does not support the extended interface.
+@publishedPartner
+@released
+*/
+EXPORT_C TAny* REComSession::GetExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid)
+	{
+	if(aInstanceKey == KNullUid)
+		User::Leave(KErrArgument);
+	TAny* object = NULL;
+	CGlobalData* globalData = CGlobalData::Instance();
+	if (globalData == 0)
+{
+__ECOM_LOG("ECOM: PANIC in REComSession::GetExtendedInterfaceL(), no global data");
+	User::Panic(KEComClientDLLPanicCategory, EEComPanic_LibraryNotInitialised);
+}
+	// Leaves with KErrNotFound if aInstanceKey not known.
+	object = globalData->LoadManager().GetExtendedInterfaceL(aInstanceKey, aExtendedInterfaceUid);
+	return object;
+	}
+/**
+Releases the extended interface associated with the supplied instance. Does nothing if the interface
+does not exist. This interface is optional, normally the interfaces are cleaned up automatically. This
+can be used if it is necessary to clean up an extended interface before the automatic cleanup occurs when
+the instance is destroyed.
+@leave	KErrNotFound When the supplied 32-bit implementation instance key is not recognised by ECom.
+@leave	KErrArgument When a null implementation instance key is passed as an argument to ECom.
+@leave	Any of the other System wide errors
+@param	aInstanceKey A 32-bit implementation instance key that is returned from a call to one of the CreateImplementationL()
+		methods. ECOM uses this implementation instance key when it is passed as an argument to the
+		DestroyedImplementation() method to identify an implementation for destruction. No meaning should be attached to
+		this implementation instance key by ECOM clients and it should not be used for any other purpose.
+@param	aExtendedInterfaceUid Identifies an extended interface to release.
+@publishedPartner
+@released
+*/
+EXPORT_C void REComSession::ManuallyReleaseExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid)
+	{
+	if(aInstanceKey == KNullUid)
+		User::Leave(KErrArgument);
+	CGlobalData* globalData = CGlobalData::Instance();
+	if (globalData == 0)
+{
+__ECOM_LOG("ECOM: PANIC in REComSession::GetExtendedInterfaceL(), no global data");
+	User::Panic(KEComClientDLLPanicCategory, EEComPanic_LibraryNotInitialised);
+}
+	// Leaves with KErrNotFound if aInstanceKey not known.
+globalData->LoadManager().ManuallyReleaseExtendedInterfaceL(aInstanceKey, aExtendedInterfaceUid);
+	}
+/**
+Retrieves a list of all the extended interfaces for the provided implementation.
+@leave          KErrNoMemory
+@leave          One of the system-wide error codes
+@param			aImplementationUid Implementation UID to fetch the extended interfaces for.
+@param			aIfInfo Return value consisting of an array containing the extended interfaces.
+@publishedPartner
+@released
+*/
+EXPORT_C void REComSession::ListExtendedInterfacesL(const TUid& aImplementationUid,RExtendedInterfacesArray& aIfInfo)
+	{
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may not be created yet.
+	REComSession& ecomSession = REComSession::OpenLC();	// NOTE: This will connect to ECom
+														// using the global instance which is returned.
+	ecomSession.ProcessListExtendedInterfacesL(aImplementationUid, aIfInfo);
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	}
+/**
+Process the list extended interface request.
+@leave          KErrNoMemory
+@leave          One of the system-wide error codes
+@param			aImplementationUid Implementation UID to fetch the extended interfaces for.
+@param			aIfInfo Return value consisting of an array containing the extended interfaces.
+*/
+void REComSession::ProcessListExtendedInterfacesL(const TUid& aImplementationUid, RExtendedInterfacesArray& aIfInfo)
+	{
+	// Ensure the array we have been given is empty
+	aIfInfo.Reset();
+	__ECOM_TRACE1("ECOM: List Extended Interfaces request for implementation %X", aImplementationUid);
+	// Package the parameters
+	TPckg<TUid> implementationUidDes(aImplementationUid);
+	TInt bufferSize = KListExtendedInterfaceBufferSize;
+	TPckg<TInt> bufferSizeDes(bufferSize);
+	RBuf8 buf;
+	buf.CreateMaxL(KListExtendedInterfaceBufferSize);
+	buf.CleanupClosePushL();
+	TIpcArgs arguments(&implementationUidDes, &bufferSizeDes, &buf);
+	TInt error = SendReceive(EListExtendedInterfaces,arguments);
+	if (error==KErrNone)
+		{
+		// When no extended interface is found, KErrNone is returned with bufferSize = 0
+		if (bufferSize>0)
+			{
+			// Now unpack the streamed data into a reconstructed array
+			RDesReadStream readStream;
+			readStream.Open(buf);
+			CleanupClosePushL(readStream);
+			CleanupStack::PushL(TCleanupItem(ResetArray, &aIfInfo));
+			TInt entryCount = bufferSize / static_cast<TInt>(sizeof(TUid));
+			if(entryCount > 0)
+				{
+				TUid interfaceUid;
+				// Build the store data then calculate the end size;
+				for(TInt i = 0; i < entryCount; ++i)
+					{
+					interfaceUid.iUid = readStream.ReadInt32L();
+					aIfInfo.AppendL(interfaceUid);
+					}
+				}
+			CleanupStack::Pop(); // NOT PopAndDestroy - we don't want to destroy the aIfInfo we've just filled
+			CleanupStack::PopAndDestroy(&readStream);
+			__ECOM_TRACE1("ECOM: Request completed OK - %d interfaces in list", entryCount);
+			}
+		}
+	else
+		{
+		// There was a problem on the server side.
+		__ECOM_TRACE1("ECOM: Request error %d", error);
+		User::Leave(error);
+		}
+	CleanupStack::PopAndDestroy(&buf);
+	}
+/**
+Gets the corresponding implementation uid for an instance key.
+This is typically used after a call to one of the CreateImplementationL() methods
+that returns the aInstanceKey value as an output arg or by an offset (aKeyOffset).
+@leave			KErrNotFound When the supplied 32-bit implementation instance key is not recognised by ECom.
+@leave			KErrArgument When a null implementation instance key is passed as an argument to ECom.
+@leave			Any of the other System wide errors
+@param			aInstanceKey A 32-bit implementation instance key that is returned from a call to one of the CreateImplementationL()
+				methods. ECOM uses this implementation instance key when it is passed as an argument to the
+				DestroyedImplementation() method to identify an implementation for destruction. No meaning should be attached to
+				this implementation instance key by ECOM clients and it should not be used for any other purpose.
+@return			TUid The uid of the corresponding implementation.
+@post			REComSession has not changed
+*/
+EXPORT_C TUid REComSession::GetImplementationUidL(TUid aInstanceKey)
+	{
+	if(aInstanceKey == KNullUid)
+		User::Leave(KErrArgument);
+	TUid implId = KNullUid;
+	CGlobalData* globalData = CGlobalData::Instance();
+	if (globalData == 0)
+{
+__ECOM_LOG("ECOM: PANIC in REComSession::ManuallyReleaseExtendedInterfaceL(), no global data");
+	User::Panic(KEComClientDLLPanicCategory, EEComPanic_LibraryNotInitialised);
+}
+	// Leaves with KErrNotFound if aInstanceKey not known.
+	implId = globalData->LoadManager().GetImplementationUidL(aInstanceKey);
+	return implId;
+	}
+/**
+Signals the destruction of an interface implementation to ECOM.
+LoadManager is responsible for destroying the implementation
+@param			aInstanceKey A 32-bit instance key that is returned from a call to one of the
+				CreateImplementationL() methods. This instance key identifies the implementation
+				for destruction. No meaning should be attached to this instance key by ECOM clients
+				and it should not be used for any other purpose.
+@post			The destruction of the Interface Implementation referred
+				to by aInstanceKey
+*/
+EXPORT_C void REComSession::DestroyedImplementation(TUid aInstanceKey)
+	{
+	if(aInstanceKey != KNullUid)
+		{
+		CGlobalData* globalData = CGlobalData::Instance();
+		if(globalData)
+			{
+			if(globalData->LoadManager().DestroyedThis(aInstanceKey))
+				{
+				globalData->EComSession().Close();
+				}
+			}
+		}
+	}
+/**
+Pack the match string of the resolution parameter and extended interfaces into a buffer for sending to server.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match,
+				Must match all extended interfaces for a match to occur.
+@param			aMatchStrExtInfBuf The return buffer containing the information of match string and extended interfaces.
+*/
+void REComSession::PackMatchStrAndExtendedInterfacesL(const TEComResolverParams& aResolutionParameters,
+													  const RExtendedInterfacesArray& aExtendedInterfaces,
+													  RBuf8& aMatchStrExtInfBuf)
+	{
+// Note the data type might be an invalid descriptor
+// because the client caller may have used a default constructed
+// TEComResolverParams. Do not access the descriptor data here. The server
+// does not access the data as it checks the size supplied below and
+// creates a zero length descriptor in such cases.
+	TPtrC8 matchString = aResolutionParameters.DataType();
+	TInt lenOfMatchString = matchString.Length();
+	TInt numOfExtendedInterfaces = aExtendedInterfaces.Count();
+	// sizeOfMatchStrExtInfBuf being the combined size of lenOfmatchType(TInt), matchString,
+	// numOfExtendedInterfaces(TInt) and extended interfaces
+	TInt sizeOfMatchStrExtInfBuf = sizeof(TInt) + lenOfMatchString + sizeof(TInt) + numOfExtendedInterfaces * sizeof(TUid);
+	aMatchStrExtInfBuf.CreateMaxL(sizeOfMatchStrExtInfBuf);
+	aMatchStrExtInfBuf.CleanupClosePushL();
+	RDesWriteStream writeStream;
+	writeStream.Open(aMatchStrExtInfBuf);
+	writeStream.WriteInt32L(lenOfMatchString);
+	//write matchString to the stream only when it's size is not zero
+	if (lenOfMatchString > 0)
+		{
+		writeStream.WriteL(matchString.Ptr(),lenOfMatchString);
+		}
+	writeStream.WriteInt32L(numOfExtendedInterfaces);
+	for(TInt i = 0; i < numOfExtendedInterfaces; ++i)
+		{
+		writeStream.WriteInt32L(aExtendedInterfaces[i].iUid);
+		}
+	writeStream.CommitL();
+	CleanupStack::Pop(&aMatchStrExtInfBuf);
+	}
+/**
+Retrieves a list of all the implementations which satisfy the
+specified interface with selection restriction to
+the specified parameters.
+Overload for internal use to ensure consistency between calls.
+This is the method which actually makes the IPC call.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aServiceId An integer specifying the ECom service variant to use.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match,
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The CResolver UID which identifies the resolver
+				implementation with the required client defined behaviour.
+@param			aImplInfoArray A reference to a client owned array which will be filled
+				with interface implementation data. The array will first be cleared and
+				all items destroyed before adding new data.
+@post			REComSession has not changed, and aImplInfoArray
+				contains the list of Implementation information for the interface.
+@see TEComResolverParams
+*/
+void REComSession::ListImplementationsL(
+TInt aServiceId,
+			TUid aInterfaceUid,
+			const RExtendedInterfacesArray& aExtendedInterfaces,
+			const TEComResolverParams& aResolutionParameters,
+			TUid aResolverUid,
+			RImplInfoPtrArray& aImplInfoArray,
+			TBool aCapabilityCheck)
+	{
+	// Ensure the array we have been given is empty
+	aImplInfoArray.ResetAndDestroy();
+	__ECOM_TRACE2("ECOM: List implementations request for i/f %X using resolver %08X", aInterfaceUid, aResolverUid);
+// Package the parameters
+// Use the UidType because it will hold our 3 possible UIDs
+// neatly, and save space in the message parameter passing structure.
+	TUidType uidtype(aInterfaceUid,KNullUid,aResolverUid);
+	//1st argument
+	TPckg<TUidType> uids(uidtype);
+	// 2nd argument which includes lenOfmatchString(TInt), matchString,
+	// numOfExtendedInterfaces(TInt) and extended Interfaces
+	RBuf8 matchStrExtInfBuf;
+	PackMatchStrAndExtendedInterfacesL(aResolutionParameters,aExtendedInterfaces,matchStrExtInfBuf);
+	matchStrExtInfBuf.CleanupClosePushL();
+	//3rd argument
+	// This KListIMplBufferSize is a patchable constant and this can be modified during buildrom time
+	TInt bufferSize=GetListImplBufferSize();
+	TInt matchType = aResolutionParameters.IsGenericMatch();
+	TListImplParam listParam={matchType,bufferSize,aCapabilityCheck};
+	TPckg<TListImplParam> listParamPckg(listParam);
+	//4th argument
+	RBuf8 buf;
+	buf.CreateMaxL(bufferSize);
+	buf.CleanupClosePushL();
+	TIpcArgs aArgs(&uids,&matchStrExtInfBuf,&listParamPckg,&buf);
+	TInt error= SendReceive(aServiceId,aArgs);
+	if (error == KErrOverflow)
+		{
+		//resend the request with the correct buffer size
+		//Get the new buffer size.
+		if (listParam.iBufferSize)
+			{
+			//re-allocate the buffer
+			buf.ReAllocL(listParam.iBufferSize);
+			TIpcArgs args(&buf);
+			User::LeaveIfError(SendReceive(ECollectImplementationsList,args));
+			error=KErrNone;
+			}
+		}
+	if (error==KErrNone)
+		{
+		if (listParam.iBufferSize)
+			{
+			// Now unpack the streamed data into a reconstructed array
+			RDesReadStream readStream;
+			readStream.Open(buf);
+			CleanupClosePushL(readStream);
+			CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray, &aImplInfoArray));
+			TInt entryCount = readStream.ReadInt32L();
+			if(entryCount)
+				{
+				// Build the store data then calculate the end size;
+				for(TInt i = 0; i < entryCount; ++i)
+					{
+					CImplementationInformation* info = CImplementationInformation::NewLC(ETrue,readStream);
+					aImplInfoArray.AppendL(info);
+					CleanupStack::Pop(info);	// Now owned by implementations
+					}
+				}
+			CleanupStack::Pop(); // NOT PopAndDestroy - we don't want to destroy the aImplInfoArray we've just filled
+			CleanupStack::PopAndDestroy(&readStream);
+			__ECOM_TRACE1("ECOM: Request completed OK - %d implementations in list", entryCount);
+			}
+		}
+	// if error == KEComErrNoInterfaceIdentified then do nothing so the client gets
+	// an empty list.  Otherwise leave with the error.
+	else if(error != KEComErrNoInterfaceIdentified)
+		{
+		CleanupStack::PopAndDestroy(&buf);
+		// There was a problem on the server side
+		__ECOM_TRACE1("ECOM: Request error %d", error);
+		User::Leave(error);
+		}
+	CleanupStack::PopAndDestroy(&buf);
+	CleanupStack::PopAndDestroy(&matchStrExtInfBuf);
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+@leave 			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aImplementationUid A UID specifying the required interface implementation.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+*/
+TAny* REComSession::ResolveAndCreateImplL(TUid aImplementationUid,
+											   TUid& aInstanceKey,
+											   TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	TEComResolverParams resolutionParameters;
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	TAny* object = ResolveAndCreateImplL(EGetImplementationCreationMethod,
+									  aImplementationUid,
+									  extendedInterfaces,
+									  resolutionParameters,
+									  KNullUid,
+									  aInstanceKey,
+									  aCreationParameters, aCreationParamsFlag);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	return object;
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+TAny* REComSession::ResolveAndCreateImplL(TUid aInterfaceUid,
+											   const TEComResolverParams& aResolutionParameters,
+											   TUid& aInstanceKey,
+											   TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	TAny* object = ResolveAndCreateImplL(EGetResolvedCreationMethod,
+									  aInterfaceUid,
+									  extendedInterfaces,
+									  aResolutionParameters,
+									  KNullUid,
+									  aInstanceKey,
+									  aCreationParameters, aCreationParamsFlag);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	return object;
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+TAny* REComSession::ResolveAndCreateImplL(TUid aInterfaceUid,
+											const RExtendedInterfacesArray& aExtendedInterfaces,
+											const TEComResolverParams& aResolutionParameters,
+											TUid& aInstanceKey,
+											TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	return ResolveAndCreateImplL(EGetResolvedCreationMethod,
+									  aInterfaceUid,
+									  aExtendedInterfaces,
+									  aResolutionParameters,
+									  KNullUid,
+									  aInstanceKey,
+									  aCreationParameters, aCreationParamsFlag);
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+Overload with a client provided CResolver.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+TAny* REComSession::ResolveAndCreateImplL(TUid aInterfaceUid,
+											   const TEComResolverParams& aResolutionParameters,
+											   TUid aResolverUid,
+											   TUid& aInstanceKey,
+											   TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	RExtendedInterfacesArray extendedInterfaces;
+	CleanupClosePushL(extendedInterfaces);
+	TAny* object = ResolveAndCreateImplL(EGetCustomResolvedCreationMethod,
+									  aInterfaceUid,
+									  extendedInterfaces,
+									  aResolutionParameters,
+									  aResolverUid,
+									  aInstanceKey,
+									  aCreationParameters, aCreationParamsFlag);
+	CleanupStack::PopAndDestroy(&extendedInterfaces);
+	return object;
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+Overload with a client provided CResolver.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+TAny* REComSession::ResolveAndCreateImplL(TUid aInterfaceUid,
+											   const RExtendedInterfacesArray& aExtendedInterfaces,
+											   const TEComResolverParams& aResolutionParameters,
+											   TUid aResolverUid,
+											   TUid& aInstanceKey,
+											   TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	return ResolveAndCreateImplL(EGetCustomResolvedCreationMethod,
+									  aInterfaceUid,
+									  aExtendedInterfaces,
+									  aResolutionParameters,
+									  aResolverUid,
+									  aInstanceKey,
+									  aCreationParameters, aCreationParamsFlag);
+	}
+/**
+Provides the instantiation method for an interface implementation
+that satisfies the specified interface.
+Overload for internal use to ensure consistency between calls.
+This is the method which actually makes the IPC call.
+@leave			KErrNoMemory
+@leave			KErrNotConnected
+@leave			KErrPermissionDenied
+@param			aServiceId An integer specifying the ECom service variant to use.
+@param			aInterfaceUid A UID specifying the required interface.
+@param			aExtendedInterfaces Identifies a set of zero or more extended interfaces to match.
+				Must match all extended interfaces for a match to occur.
+@param			aResolutionParameters Specifies any additional implementation
+characteristics to be fulfilled, maybe empty.
+@param			aResolverUid The Uid of a CResolver with client defined behaviour.
+@param			aInstanceKey A 32 bit instance key returned by the ECom framework that
+				identifies the returned instance.
+@param			aCreationParameters A pointer to the creation parameter
+				structure passed to the creation method when called.
+@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence
+				of aCreationParameters. Will be ETrue even for if the value of
+				aCreationParameters is NULL.
+@return			TAny* a pointer to the fully constructed implementation
+@post			The requested interface implementation is identified,
+				and the instantiation method pointer is returned.
+@see TEComResolverParams
+*/
+TAny* REComSession::ResolveAndCreateImplL(TInt aServiceId,
+											   TUid aInterfaceUid,
+											   const RExtendedInterfacesArray& aExtendedInterfaces,
+											   const TEComResolverParams& aResolutionParameters,
+											   TUid aResolverUid,
+											   TUid& aInstanceKey,
+											   TAny* aCreationParameters, TBool aCreationParamsFlag)
+	{
+	// Package the parameters
+	// 1st argument. Use the UidType because it will hold our 3 possible UIDs
+	// (aInterfaceUid, aInstanceKey and aResolverUid)
+	// neatly, and save space in the message parameter passing structure.
+	TUidType uidStore(aInterfaceUid, aInstanceKey, aResolverUid);
+	TPckg<TUidType> uids(uidStore);
+// Store the arguments, note the data type might ba an invalid descriptor
+// beacuse the client caller may have used a default constructed
+// TEComResolverParams. Do not access the descriptor data here. The server
+// does not access the data as it checks the size supplied below and
+// creates a zero length descriptor in such cases.
+	// 2nd argument which includes lenOfmatchString(TInt), matchString,
+	// numOfExtendedInterfaces(TInt) and extended Interfaces
+	RBuf8 matchStrExtInfBuf;
+	PackMatchStrAndExtendedInterfacesL(aResolutionParameters,aExtendedInterfaces,matchStrExtInfBuf);
+	matchStrExtInfBuf.CleanupClosePushL();
+	// 3rd argument
+	TInt matchType = aResolutionParameters.IsGenericMatch();
+	// 4th argument
+	TEntry dllInfo;
+	TPckg<TEntry> dllPkg(dllInfo);
+// And call the server
+	User::LeaveIfError(SendReceive(aServiceId, TIpcArgs(&uids,&matchStrExtInfBuf,matchType,&dllPkg)));
+	CleanupStack::PopAndDestroy(&matchStrExtInfBuf);
+// delegate to LoadManager to instantiate the object
+	CGlobalData* globalData = CGlobalData::Instance();
+	TAny* object=(TAny*)globalData->LoadManager().ImplementationObjectL(uidStore[KDtorKeyUidIndex],
+																		dllInfo,
+																		aCreationParameters,
+																		aCreationParamsFlag,
+																		aInstanceKey);
+	return object;
+	}
+/**
+This method is provided for the internal testing of the ECOM component.
+@param aArgs Arguments used for sending and receiving parameters
+@leave ... One of the system-wide error codes
+@internalComponent
+*/
+EXPORT_C void REComSession::SetGetParametersL(const TIpcArgs &aArgs)
+	{
+	// Open a local instance for the
+	// interface creation, because this is a static
+	// method and we may be not created yet.
+	// call FinalClose() in the event of a leave
+	CleanupStack::PushL(TCleanupItem(CleanupFinalClose, NULL));
+	// NOTE: This will connect to ECom
+	// using the global instance which is returned.
+	REComSession& ecomSession = REComSession::OpenLC();
+	TInt error = ecomSession.SendReceive(ESetGetParameters, aArgs);
+	if(error != KErrNone)
+		{
+		// There was a problem on the server side
+		__ECOM_TRACE1("ECOM: Request error %d.", error);
+		User::Leave(error);
+		}
+	CleanupStack::PopAndDestroy(&ecomSession);
+	CleanupStack::Pop(); // CleanupFinalClose
+	}