diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/pluginfw/Framework/frame/EComSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/pluginfw/Framework/frame/EComSession.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,2195 @@ +// 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 +#include "EComDebug.h" +#include +#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(aPtr))->ResetAndDestroy(); + } + +static void ResetArray(TAny* aPtr) + { + (static_cast(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 implementationUidDes(aImplementationUid); + TInt bufferSize = KListExtendedInterfaceBufferSize; + TPckg 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(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 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 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 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 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 + } + +