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