// Copyright (c) 2007-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 some classes

// to be provided by ECom.

// 1. Using the CExampleInterface class as a base.

// 2. Example of how extended interfaces could work.

// 

//

/**

 @file

 @publishedAll

*/

#include "Interface.h"

#include "ecom/extendedinterfaceimplementationproxy.h"

#include "TestUtilities.h"	// For __FILE__LINE__

const TUid KImplUid1 = {0x10009E38};

const TUid KImplUid2 = {0x10009E3A};

const TUid KImplUid3 = {0x10009E3B};

// ____________________________________________________________________________

//

/**

	Intended usage: This class implements the functionality promised by

	the CExampleInterface and MExampleInterfaceExtended definition classes. 

	It does little apart from provides a test instance

	which may be retrieved and run for testing purposes. This is an example of

	how extended interface is implemented in the same class as the original and 

	how to get/release the extended interface which is implemented in different class.

 */

class CImplementationClassTen : public CExampleInterface, public MExampleInterfaceExtended

{

// Methods

public:

	static CImplementationClassTen* NewL(TAny* aInitParams);

	virtual ~CImplementationClassTen();

	void DoMethodL();

	TInt FireAndForget();

	TUid ImplId();

	virtual void DoMethodExtended();  //from MExampleInterfaceExtended

	static TAny* GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& releaseObject);

	static void ReleaseExtendedInterface(TAny* aObject, const TUid& aInterface);

private:

	CImplementationClassTen();

	void ConstructL(TAny* aInitParams);

// Provide the CActive overloads

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

private:

/** A place for allocating some memory in the ConstructL */

	HBufC*	iInternalDescriptor;

/** An int to be stored in TLS to test its usage */

	TInt	iTLSInt;

/** Uid of the extended interface */

	TUid iExtendedInterfaceUid;		

};  // End of CImplementationClassTen definition

// ____________________________________________________________________________

//

/**

	Intended usage: This class implements the functionality promised by

	the MExampleInterfaceExtended2 definition class. This is an extended interface of

	CImplementationClassTen. This is a sample extended interface that is

	separate from the main interface. This extended interface does nothing, but shows

    how one can set up a separately instantiated extended interface.

 */

class CImplementationClassTenExtended : public CBase, public MExampleInterfaceExtended2

{

// Methods

public:

	static CImplementationClassTenExtended* NewL();

	virtual ~CImplementationClassTenExtended();

	virtual void DoMethodExtended2();  //from MExampleInterfaceExtended2

private:

	CImplementationClassTenExtended();

// Attribute

private:

	TUid iExtendedInterfaceUid;		

};  // End of CImplementationClassTenExtended definition

// ____________________________________________________________________________

//

/**

	Intended usage: This class implements the functionality promised by

	the MExampleInterfaceExtended2 definition class. This is an extended interface of

	CImplementationClassTen. It is the same as CImplementationClassTenExtended,

	but just shows that it is possible to have multiple extended interfaces in one implementation.

 */

class CImplementationClassTenExtended2 : public CBase, public MExampleInterfaceExtended2

{

// Methods

public:

	static CImplementationClassTenExtended2* NewL();

	virtual ~CImplementationClassTenExtended2();

	virtual void DoMethodExtended2(); //from MExampleInterfaceExtended2

private:

	CImplementationClassTenExtended2();

// Attribute

private:

	TUid iExtendedInterfaceUid;		

};  // End of CImplementationClassTenExtended2 definition

// __________________________________________________________________________

// Implementation

/**

Safe construction which leaves nothing upon the cleanup stack

@param			aInitParams Initialization parameters

@return			CImplementationClassTen* a pointer to the fully instantiated CImplementationClassTen object

*/

CImplementationClassTen* CImplementationClassTen::NewL(TAny* aInitParams)

	{

	CImplementationClassTen* self=new(ELeave) CImplementationClassTen();  

	CleanupStack::PushL(self);	

	self->ConstructL(aInitParams); 

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTen

 */

CImplementationClassTen::~CImplementationClassTen()

	{

	delete iInternalDescriptor;

	Dll::FreeTls();

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTen::CImplementationClassTen()

: CExampleInterface()

	{

	//set the extended interface Uid

	iExtendedInterfaceUid.iUid = 0x10009E44;

	}

/**

Safely complete the initialization of the constructed object.

@param			aInitParams Initialization parameters

*/

void CImplementationClassTen::ConstructL(TAny* aInitParams)

	{

	TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*,aInitParams);

	if(params)

		{

		if(params->descriptor)

			{

			iInternalDescriptor = params->descriptor->AllocL();

			}

		}

	User::LeaveIfError(Dll::SetTls(&iTLSInt));

	}

/**

Overload of the pure interface method.Representative of a method provided on

the interface by the interface definer.

 */

void CImplementationClassTen::DoMethodL()

	{

	// Access TLS to ensure it has been set properly

	ASSERT(Dll::Tls() != NULL);

	}

/**

Overload of the pure interface method asynchronous function which

an interface definer could specify.

@return			TInt KErrNone for success.

 */

TInt CImplementationClassTen::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTen::RunL()

	{

	// Do nothing : should never be called

	__ASSERT_DEBUG(EFalse,User::Invariant());

	}

void CImplementationClassTen::DoCancel()

	{

	// Do nothing

	}

TInt CImplementationClassTen::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

@return			TUid (ECOM's Implementation Uid for this class.)

 */

TUid CImplementationClassTen::ImplId()

	{

	return KImplUid1;

	}

/**

Extended interface method. Called to verify the Extended interface.

 */

void CImplementationClassTen::DoMethodExtended()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E44);

	}

/**

Get the extended interface. This method will be called by ECOM, so the method must

follow the signature defined by TProxyExtendedInterfaceGetPtrL. This must be a static

method since it is used in the proxy table.

@param			aObject A pointer to the instantiation interface (CImplementationClassTen

				in this case) instance. This will be provided by ECOM. It must be provided

				as a parameter,	as this method is a static method (and must be a static

				method because it is called by the proxy table).

@param			aExtendedInterface The extended interface to fetch. Must be a unique UID.

@param			aBitFlags Flags used for communication between plugin's and ECOM. Currently

				used to signal if an extended interface requires release.

@param			aReleaseObject return parameter, provides ECOM with the object to destroy

				if the interface requires to be released.

@return			TAny* a pointer to the fully constructed extended interface object

*/

TAny* CImplementationClassTen::GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& aReleaseObject)

	{

	//Initialise the release bit

	aBitFlags = aBitFlags & 0xFFFFFFFE;

	TAny* ret = NULL;

	switch (aExtendedInterface.iUid)

		{

		case 0x10009E44:

		    {

	        // No release is required, so do not modify aBitFlags.

		    ret = static_cast<MExampleInterfaceExtended*>(static_cast<CImplementationClassTen*>(aObject));

		    break;

		    }

		case 0x10009E45:

		    {

		    // Indicate to caller that release is required

		    aBitFlags = aBitFlags | KReleaseRequiredMask;

		    CImplementationClassTenExtended *classExt = CImplementationClassTenExtended::NewL();

		    // Must set the release object for ECOM to release later, this will not be the same as the interface object that is returned.

		    aReleaseObject = classExt;

		    ret = static_cast<MExampleInterfaceExtended2*>(classExt);

		    break;

		    }

		case 0x10009E46:

		    {

		    // Indicate to caller that release is required

		    aBitFlags = aBitFlags | KReleaseRequiredMask;

		    CImplementationClassTenExtended2 *classExt = CImplementationClassTenExtended2::NewL();

		    // Must set the release object for ECOM to release later, this will not be the same as the interface object that is returned.

		    aReleaseObject = classExt;

		    ret = static_cast<MExampleInterfaceExtended2*>(classExt);

		    break;

		    }

		default:

			{

			break;    

			}

		}

	return ret;

	}

/**

Release the specified extended interface. This method will be called by ECOM, so the method must

follow the signature defined by TProxyExtendedInterfaceReleasePtr. This must be a static

method since it is used in the proxy table.

method.

@param			aReleaseObject provides ECOM with the object to destroy

				if the interface requires to be released.

@param			aExtendedInterface extended interface that is to be released

@return			TAny* a pointer to the fully constructed extended interface object

*/

void CImplementationClassTen::ReleaseExtendedInterface(TAny* aReleaseObject,const TUid& aExtendedInterface)

	{

	switch (aExtendedInterface.iUid)

	    {

	    case 0x10009E45:

			{

	        // this object is an interface that was a separate object from the main instantiated object, and must be cleaned up.

			CImplementationClassTenExtended* classExt = static_cast<CImplementationClassTenExtended*>(aReleaseObject);

			delete classExt;

			break;

	        }

 		case 0x10009E46:

			{

	        // this object is an interface that was a separate object from the main instantiated object, and must be cleaned up.

			CImplementationClassTenExtended2* classExt = static_cast<CImplementationClassTenExtended2*>(aReleaseObject);

			delete classExt;

			break;

	        }

	    default:

			{

			break;    

			}    

	    }

	}

// __________________________________________________________________________

//

// Implementation of CImplementationClassTenExtended

/**

Safe construction which leaves nothing upon the cleanup stack

@return			CImplementationClassTen* a pointer to the fully instantiated CImplementationClassTen object

*/

CImplementationClassTenExtended* CImplementationClassTenExtended::NewL()

	{

	CImplementationClassTenExtended* self=new(ELeave) CImplementationClassTenExtended(); 

	return self;

	}

/**

Destructor of CImplementationClassTenExtended

 */

CImplementationClassTenExtended::~CImplementationClassTenExtended()

	{

	// do nothing

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTenExtended::CImplementationClassTenExtended()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E45;

	}

/**

Extended interface.

*/

void CImplementationClassTenExtended::DoMethodExtended2()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E45);

	}

// __________________________________________________________________________

//

// Implementation of CImplementationClassTenExtended2

/**

Safe construction which leaves nothing upon the cleanup stack

@return			CImplementationClassTenExtended2* a pointer to the fully instantiated CImplementationClassTen object

*/

CImplementationClassTenExtended2* CImplementationClassTenExtended2::NewL()

	{

	CImplementationClassTenExtended2* self=new(ELeave) CImplementationClassTenExtended2(); 

	return self;

	}

/**

Destructor of CImplementationClassTenExtended2

 */

CImplementationClassTenExtended2::~CImplementationClassTenExtended2()

	{

	// do nothing

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTenExtended2::CImplementationClassTenExtended2()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E46;

	}

/**

Extended interface.

*/

void CImplementationClassTenExtended2::DoMethodExtended2()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E46);

	}

// CImplementationClassTenBasic implementation

// ____________________________________________________________________________

//

/**

This class implements the functionality promised by

the CExampleInterface definition class. It does little apart from provides a test instance

which may be retrieved and run for testing purposes. This is an example that no extended interface 

is implemented in this class.

*/

class CImplementationClassTenBasic : public CExampleInterface

{

// Methods

public:

	static CImplementationClassTenBasic* NewL(TAny* aInitParams);

	virtual ~CImplementationClassTenBasic();

	void DoMethodL();

	TInt FireAndForget();

	TUid ImplId();

private:

	CImplementationClassTenBasic();

	void ConstructL(TAny* aInitParams);

	// Provide the CActive overloads

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

private:

/** A place for allocating some memory in the ConstructL */

	HBufC*	iInternalDescriptor;

/** An int to be stored in TLS to test its usage */

	TInt	iTLSInt;

};  // End of CImplementationClassTenBasic definition

// __________________________________________________________________________

// Implementation

/**

Safe construction which leaves nothing upon the cleanup stack

@param			aInitParams The parameter struct used for initialising this object

@return			CImplementationClassTenBasic* a pointer to the fully instantiated CImplementationClassTenBasic object

*/

CImplementationClassTenBasic* CImplementationClassTenBasic::NewL(TAny* aInitParams)

	{

	CImplementationClassTenBasic* self=new(ELeave) CImplementationClassTenBasic();  

	CleanupStack::PushL(self);	

	self->ConstructL(aInitParams); 

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTenBasic

 */

CImplementationClassTenBasic::~CImplementationClassTenBasic()

	{

	delete iInternalDescriptor;

	Dll::FreeTls();

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTenBasic::CImplementationClassTenBasic()

: CExampleInterface()

	{

	}

/**

Completes the safe construction of the CImplementationClassTenBasic object

@param			aInitParams The parameter struct used for initialising this object

 */

void CImplementationClassTenBasic::ConstructL(TAny* aInitParams)

	{

	TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*, aInitParams);

	if(params)

		{

		if(params->descriptor)

			{

			iInternalDescriptor = params->descriptor->AllocL();

			}

		}

	User::LeaveIfError(Dll::SetTls(&iTLSInt));

	}

/**

Overload of the pure interface method.Representative of a method provided on

the interface by the interface definer.

 */

void CImplementationClassTenBasic::DoMethodL()

	{

	// Access TLS to ensure it has been set properly

	ASSERT(Dll::Tls() != NULL);

	}

/**

Overload of the pure interface method asynchronous function which

an interface definer could specify. 

@return			TInt KErrNone for success.

 */

TInt CImplementationClassTenBasic::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTenBasic::RunL()

	{

	// Do nothing : should never be called

	__ASSERT_DEBUG(EFalse,User::Invariant());

	}

void CImplementationClassTenBasic::DoCancel()

	{

	// Do nothing

	}

TInt CImplementationClassTenBasic::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

@return			TUid (ECOM's Implementation Uid for this class.)

 */

TUid CImplementationClassTenBasic::ImplId()

	{

	return KImplUid2;

	}

// ____________________________________________________________________________

//

/**

Intended usage: This class implements the functionality promised by

the CExampleInterface defintion class. It does little apart from provides a test instance

which may be retrieved and run for testing purposes.This is an example of

how extended interface is implemented in the same class as the original.

 */

class CImplementationClassTen2 : public CExampleInterface, public MExampleInterfaceExtended

{

// Methods

public:

	static CImplementationClassTen2* NewL(TAny* aInitParams);

	virtual ~CImplementationClassTen2();

	void DoMethodL();

	TInt FireAndForget();

	TUid ImplId();

	static TAny* GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& releaseObject);

 public: 

	virtual void DoMethodExtended(); // From MExampleInterfaceExtended

private:

	CImplementationClassTen2();

	void ConstructL(TAny* aInitParams);

// Provide the CActive overloads

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

private:

/** A place for allocating some memory in the ConstructL */

	HBufC*	iInternalDescriptor;

/** An int to be stored in TLS to test its usage */

	TInt	iTLSInt;

/** Uid of the extended interface */

	TUid iExtendedInterfaceUid;			

};  // End of CImplementationClassTen2 definition

// __________________________________________________________________________

// Implementation

/**

Standardised safe construction which leaves nothing the cleanup stack.

@param			aInitParams The parameter struct used for initialising this object

@return			CImplementationClassTen2* The class instance.

 */

CImplementationClassTen2* CImplementationClassTen2::NewL(TAny* aInitParams)

	{

	CImplementationClassTen2* self=new(ELeave) CImplementationClassTen2(); 

	CleanupStack::PushL(self);	

	self->ConstructL(aInitParams); 

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTen2

 */

CImplementationClassTen2::~CImplementationClassTen2()

	{

	delete iInternalDescriptor;

	Dll::FreeTls();

	}

/**

Default Constructor

*/

CImplementationClassTen2::CImplementationClassTen2()

: CExampleInterface()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E44;

	}

/**

Completes the safe construction of the CImplementationClassTenBasic object

@param			aInitParams The parameter struct used for initialising this object

 */

void CImplementationClassTen2::ConstructL(TAny* aInitParams)

	{

	TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*, aInitParams);

	if(params)

		{

		if(params->descriptor)

			{

			iInternalDescriptor = params->descriptor->AllocL();

			}

		}

	User::LeaveIfError(Dll::SetTls(&iTLSInt));

	}

/**

Overload of the pure interface method.Representative of a method provided on

the interface by the interface definer.

 */

void CImplementationClassTen2::DoMethodL()

	{

	// Access TLS to ensure it has been set properly

	ASSERT(Dll::Tls() != NULL);

	}

/**

Overload of the pure interface method asynchronous function which

an interface definer could specify. 

@return			TInt KErrNone for success.

 */

TInt CImplementationClassTen2::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTen2::RunL()

	{

	// Do nothing : should never be called

	__ASSERT_DEBUG(EFalse,User::Invariant());

	}

void CImplementationClassTen2::DoCancel()

	{

	// Do nothing

	}

TInt CImplementationClassTen2::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

@return			TUid (ECOM's Implementation Uid for this class.)

 */

TUid CImplementationClassTen2::ImplId()

	{

	return KImplUid3;

	}

/**

Extended interface method. Called to verify the Extended interface.

 */

void CImplementationClassTen2::DoMethodExtended()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E44);

	}

/**

Get the extended interface. This method will be called by ECOM, so the method must

follow the signature defined by TProxyExtendedInterfaceGetPtrL.This must be a static

method since it is used in the proxy table.

@param			aObject A pointer to the instantiation interface (CImplementationClassTen

				in this case) instance. This will be provided by ECOM. It must be provided

				as a parameter,	as this method is a static method (and must be a static

				method because it is called by the proxy table).

@param			aExtendedInterface The extended interface to fetch. Must be a unique UID.

@param			aBitFlags Flags used for communication between plugin's and ECOM. Currently

				used to signal if an extended interface requires release.

@param			aReleaseObject return parameter, provides ECOM with the object to destroy

				if the interface requires to be released.

@return			TAny* a pointer to the fully constructed extended interface object

*/

TAny* CImplementationClassTen2::GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& /*aBitFlags*/,TAny*& /*releaseObject*/)

	{

	TAny* ret = NULL;

	switch (aExtendedInterface.iUid)

		{

		case 0x10009E44:

		    {

	        // No release is required, so do not modify aBitFlags.

		    ret = static_cast<MExampleInterfaceExtended*>(static_cast<CImplementationClassTen2*>(aObject));

		    break;

		    }

		default:

			{

			break;    

			}    

		}

	return ret;

	}

// __________________________________________________________________________

// Exported proxy for instantiation method resolution

// Define the interface UIDs

const TImplementationProxy3 KImplementationTable[] =

	{

	IMPLEMENTATION_PROXY_ENTRY3(0x10009E38,CImplementationClassTen::NewL,CImplementationClassTen::GetExtendedInterfaceL,CImplementationClassTen::ReleaseExtendedInterface),

	IMPLEMENTATION_PROXY_ENTRY3(0x10009E3A,CImplementationClassTenBasic::NewL,0,0),

	IMPLEMENTATION_PROXY_ENTRY3(0x10009E3B,CImplementationClassTen2::NewL,CImplementationClassTen2::GetExtendedInterfaceL,0)

	};

EXPORT_C const TImplementationProxy3* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy3);

	return KImplementationTable;

	}