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

// 

//

/**

 @file

 @internalComponent

*/

#include "exampletwelve.h"

// __________________________________________________________________________

//

// Implementation of CImplementationClassTwelve

/**

Safe construction which leaves nothing upon the cleanup stack

@param			aInitParams Initialization parameters

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

*/

CImplementationClassTwelve* CImplementationClassTwelve::NewL(TAny* aInitParams)

	{

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

	CleanupStack::PushL(self);	

	self->ConstructL(aInitParams);

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTwelve

 */

CImplementationClassTwelve::~CImplementationClassTwelve()

	{

	delete iInternalDescriptor;

	Dll::SetTls(NULL);

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTwelve::CImplementationClassTwelve()

: CExampleInterface()

	{

	//set the extended interface Uid

	iExtendedInterfaceUid.iUid = 0x10009E44;

	}

/**

Safely complete the initialization of the constructed object.

@param			aInitParams Initialization parameters

*/

void CImplementationClassTwelve::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 CImplementationClassTwelve::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 CImplementationClassTwelve::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTwelve::RunL()

	{

	// Do nothing : should never be called

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

	}

void CImplementationClassTwelve::DoCancel()

	{

	// Do nothing

	}

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

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

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

 */

TUid CImplementationClassTwelve::ImplId()

	{

	return KImplUid1;

	}

/**

Extended interface method. Called to verify the Extended interface.

 */

void CImplementationClassTwelve::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 (CImplementationClassTwelve

				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* CImplementationClassTwelve::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<CImplementationClassTwelve*>(aObject));

		    break;

		    }

		case 0x10009E45:

		    {

		    // Indicate to caller that release is required

		    aBitFlags = aBitFlags | KReleaseRequiredMask;

		    CImplementationClassTwelveExtended *classExt = CImplementationClassTwelveExtended::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;

		    CImplementationClassTwelveExtended2 *classExt = CImplementationClassTwelveExtended2::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 CImplementationClassTwelve::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.

			CImplementationClassTwelveExtended* classExt = static_cast<CImplementationClassTwelveExtended*>(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.

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

			delete classExt;

			break;

	        }

	    default:

			{

			break;    

			}    

	    }

	}

// __________________________________________________________________________

//

// Implementation of CImplementationClassTwelveExtended

/**

Safe construction which leaves nothing upon the cleanup stack

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

*/

CImplementationClassTwelveExtended* CImplementationClassTwelveExtended::NewL()

	{

	CImplementationClassTwelveExtended* self=new(ELeave) CImplementationClassTwelveExtended();  // calls c'tor

	return self;

	}

/**

Destructor of CImplementationClassTwelveExtended

 */

CImplementationClassTwelveExtended::~CImplementationClassTwelveExtended()

	{

	// do nothing

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTwelveExtended::CImplementationClassTwelveExtended()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E45;

	}

/**

Extended interface.

*/

void CImplementationClassTwelveExtended::DoMethodExtended2()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E45);

	}

// __________________________________________________________________________

//

// Implementation of CImplementationClassTwelveExtended2

/**

Safe construction which leaves nothing upon the cleanup stack

@return			CImplementationClassTwelveExtended2* a pointer to the fully instantiated CImplementationClassTwelve object

*/

CImplementationClassTwelveExtended2* CImplementationClassTwelveExtended2::NewL()

	{

	CImplementationClassTwelveExtended2* self=new(ELeave) CImplementationClassTwelveExtended2();  // calls c'tor

	return self;

	}

/**

Destructor of CImplementationClassTwelveExtended2

 */

CImplementationClassTwelveExtended2::~CImplementationClassTwelveExtended2()

	{

	// do nothing

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTwelveExtended2::CImplementationClassTwelveExtended2()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E46;

	}

/**

Extended interface.

*/

void CImplementationClassTwelveExtended2::DoMethodExtended2()

	{

	//check the extended interface uid has been set properly

	ASSERT(iExtendedInterfaceUid.iUid == 0x10009E46);

	}

// __________________________________________________________________________

// Implementation of CImplementationClassTwelveBasic

/**

Safe construction which leaves nothing upon the cleanup stack

@param			aInitParams The parameter struct used for initialising this object

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

*/

CImplementationClassTwelveBasic* CImplementationClassTwelveBasic::NewL(TAny* aInitParams)

	{

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

	CleanupStack::PushL(self);	

	self->ConstructL(aInitParams); 

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTwelveBasic

 */

CImplementationClassTwelveBasic::~CImplementationClassTwelveBasic()

	{

	delete iInternalDescriptor;

	Dll::FreeTls();

	}

/**

Default Constructor : usable only by derived classes

*/

CImplementationClassTwelveBasic::CImplementationClassTwelveBasic()

: CExampleInterface()

	{

	}

/**

Completes the safe construction of the CImplementationClassTwelveBasic object

@param			aInitParams The parameter struct used for initialising this object

 */

void CImplementationClassTwelveBasic::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 CImplementationClassTwelveBasic::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 CImplementationClassTwelveBasic::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTwelveBasic::RunL()

	{

	// Do nothing : should never be called

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

	}

void CImplementationClassTwelveBasic::DoCancel()

	{

	// Do nothing

	}

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

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

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

 */

TUid CImplementationClassTwelveBasic::ImplId()

	{

	return KImplUid2;

	}

// __________________________________________________________________________

// Implementation of CImplementationClassTwelve2

/**

Standardised safe construction which leaves nothing the cleanup stack.

@param			aInitParams The parameter struct used for initialising this object

@return			CImplementationClassTwelve2* The class instance.

 */

CImplementationClassTwelve2* CImplementationClassTwelve2::NewL(TAny* aInitParams)

	{

	CImplementationClassTwelve2* self=new(ELeave) CImplementationClassTwelve2();  // calls c'tor

	CleanupStack::PushL(self);	// Make the construction safe by using the cleanup stack

	self->ConstructL(aInitParams); // Complete the 'construction'.

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor of CImplementationClassTwelve2

 */

CImplementationClassTwelve2::~CImplementationClassTwelve2()

	{

	delete iInternalDescriptor;

	Dll::FreeTls();

	}

/**

Default Constructor

*/

CImplementationClassTwelve2::CImplementationClassTwelve2()

: CExampleInterface()

	{

	//set the extended interface uid

	iExtendedInterfaceUid.iUid = 0x10009E44;

	}

/**

Completes the safe construction of the CImplementationClassTwelveBasic object

@param			aInitParams The parameter struct used for initialising this object

 */

void CImplementationClassTwelve2::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 CImplementationClassTwelve2::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 CImplementationClassTwelve2::FireAndForget()

	{

	return KErrNone;			

	}

// Provide the CActive overloads

void CImplementationClassTwelve2::RunL()

	{

	// Do nothing : should never be called

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

	}

void CImplementationClassTwelve2::DoCancel()

	{

	// Do nothing

	}

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

	{

	return KErrNone;

	}

/**

To verify the object returned by ECOM.

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

 */

TUid CImplementationClassTwelve2::ImplId()

	{

	return KImplUid3;

	}

/**

Extended interface method. Called to verify the Extended interface.

 */

void CImplementationClassTwelve2::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 (CImplementationClassTwelve

				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* CImplementationClassTwelve2::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<CImplementationClassTwelve2*>(aObject));

		    break;

		    }

		default:

			{

			break;    

			}    

		}

	return ret;

	}