diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/Example/exampletwelve.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/Example/exampletwelve.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,547 @@ +// 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(static_cast(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(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(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(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(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(static_cast(aObject)); + break; + } + default: + { + break; + } + } + return ret; + }