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

 	}