--- /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 <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
+ }
+
+