// 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));