1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/Example/exampleten.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,727 @@
1.4 +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// The implementation of some classes
1.18 +// to be provided by ECom.
1.19 +// 1. Using the CExampleInterface class as a base.
1.20 +// 2. Example of how extended interfaces could work.
1.21 +//
1.22 +//
1.23 +
1.24 +/**
1.25 + @file
1.26 + @publishedAll
1.27 +*/
1.28 +
1.29 +#include "Interface.h"
1.30 +#include "ecom/extendedinterfaceimplementationproxy.h"
1.31 +#include "TestUtilities.h" // For __FILE__LINE__
1.32 +
1.33 +const TUid KImplUid1 = {0x10009E38};
1.34 +const TUid KImplUid2 = {0x10009E3A};
1.35 +const TUid KImplUid3 = {0x10009E3B};
1.36 +
1.37 +// ____________________________________________________________________________
1.38 +//
1.39 +/**
1.40 + Intended usage: This class implements the functionality promised by
1.41 + the CExampleInterface and MExampleInterfaceExtended definition classes.
1.42 + It does little apart from provides a test instance
1.43 + which may be retrieved and run for testing purposes. This is an example of
1.44 + how extended interface is implemented in the same class as the original and
1.45 + how to get/release the extended interface which is implemented in different class.
1.46 + */
1.47 +class CImplementationClassTen : public CExampleInterface, public MExampleInterfaceExtended
1.48 +{
1.49 +// Methods
1.50 +public:
1.51 + static CImplementationClassTen* NewL(TAny* aInitParams);
1.52 + virtual ~CImplementationClassTen();
1.53 + void DoMethodL();
1.54 + TInt FireAndForget();
1.55 + TUid ImplId();
1.56 + virtual void DoMethodExtended(); //from MExampleInterfaceExtended
1.57 + static TAny* GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& releaseObject);
1.58 + static void ReleaseExtendedInterface(TAny* aObject, const TUid& aInterface);
1.59 +private:
1.60 + CImplementationClassTen();
1.61 + void ConstructL(TAny* aInitParams);
1.62 +// Provide the CActive overloads
1.63 + void RunL();
1.64 + void DoCancel();
1.65 + TInt RunError(TInt aError);
1.66 +private:
1.67 +/** A place for allocating some memory in the ConstructL */
1.68 + HBufC* iInternalDescriptor;
1.69 +/** An int to be stored in TLS to test its usage */
1.70 + TInt iTLSInt;
1.71 +/** Uid of the extended interface */
1.72 + TUid iExtendedInterfaceUid;
1.73 +}; // End of CImplementationClassTen definition
1.74 +
1.75 +// ____________________________________________________________________________
1.76 +//
1.77 +/**
1.78 + Intended usage: This class implements the functionality promised by
1.79 + the MExampleInterfaceExtended2 definition class. This is an extended interface of
1.80 + CImplementationClassTen. This is a sample extended interface that is
1.81 + separate from the main interface. This extended interface does nothing, but shows
1.82 + how one can set up a separately instantiated extended interface.
1.83 + */
1.84 +class CImplementationClassTenExtended : public CBase, public MExampleInterfaceExtended2
1.85 +{
1.86 +// Methods
1.87 +public:
1.88 + static CImplementationClassTenExtended* NewL();
1.89 + virtual ~CImplementationClassTenExtended();
1.90 + virtual void DoMethodExtended2(); //from MExampleInterfaceExtended2
1.91 +private:
1.92 + CImplementationClassTenExtended();
1.93 +// Attribute
1.94 +private:
1.95 + TUid iExtendedInterfaceUid;
1.96 +}; // End of CImplementationClassTenExtended definition
1.97 +
1.98 +// ____________________________________________________________________________
1.99 +//
1.100 +/**
1.101 + Intended usage: This class implements the functionality promised by
1.102 + the MExampleInterfaceExtended2 definition class. This is an extended interface of
1.103 + CImplementationClassTen. It is the same as CImplementationClassTenExtended,
1.104 + but just shows that it is possible to have multiple extended interfaces in one implementation.
1.105 + */
1.106 +class CImplementationClassTenExtended2 : public CBase, public MExampleInterfaceExtended2
1.107 +{
1.108 +// Methods
1.109 +public:
1.110 + static CImplementationClassTenExtended2* NewL();
1.111 + virtual ~CImplementationClassTenExtended2();
1.112 + virtual void DoMethodExtended2(); //from MExampleInterfaceExtended2
1.113 +private:
1.114 + CImplementationClassTenExtended2();
1.115 +// Attribute
1.116 +private:
1.117 + TUid iExtendedInterfaceUid;
1.118 +}; // End of CImplementationClassTenExtended2 definition
1.119 +
1.120 +
1.121 +// __________________________________________________________________________
1.122 +// Implementation
1.123 +
1.124 +/**
1.125 +Safe construction which leaves nothing upon the cleanup stack
1.126 +@param aInitParams Initialization parameters
1.127 +@return CImplementationClassTen* a pointer to the fully instantiated CImplementationClassTen object
1.128 +*/
1.129 +CImplementationClassTen* CImplementationClassTen::NewL(TAny* aInitParams)
1.130 + {
1.131 + CImplementationClassTen* self=new(ELeave) CImplementationClassTen();
1.132 + CleanupStack::PushL(self);
1.133 + self->ConstructL(aInitParams);
1.134 + CleanupStack::Pop(self);
1.135 + return self;
1.136 + }
1.137 +
1.138 +/**
1.139 +Destructor of CImplementationClassTen
1.140 + */
1.141 +CImplementationClassTen::~CImplementationClassTen()
1.142 + {
1.143 + delete iInternalDescriptor;
1.144 + Dll::FreeTls();
1.145 + }
1.146 +
1.147 +/**
1.148 +Default Constructor : usable only by derived classes
1.149 +*/
1.150 +CImplementationClassTen::CImplementationClassTen()
1.151 +: CExampleInterface()
1.152 + {
1.153 + //set the extended interface Uid
1.154 + iExtendedInterfaceUid.iUid = 0x10009E44;
1.155 + }
1.156 +
1.157 +/**
1.158 +Safely complete the initialization of the constructed object.
1.159 +@param aInitParams Initialization parameters
1.160 +*/
1.161 +void CImplementationClassTen::ConstructL(TAny* aInitParams)
1.162 + {
1.163 + TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*,aInitParams);
1.164 + if(params)
1.165 + {
1.166 + if(params->descriptor)
1.167 + {
1.168 + iInternalDescriptor = params->descriptor->AllocL();
1.169 + }
1.170 + }
1.171 + User::LeaveIfError(Dll::SetTls(&iTLSInt));
1.172 + }
1.173 +
1.174 +/**
1.175 +Overload of the pure interface method.Representative of a method provided on
1.176 +the interface by the interface definer.
1.177 + */
1.178 +void CImplementationClassTen::DoMethodL()
1.179 + {
1.180 + // Access TLS to ensure it has been set properly
1.181 + ASSERT(Dll::Tls() != NULL);
1.182 + }
1.183 +
1.184 +/**
1.185 +Overload of the pure interface method asynchronous function which
1.186 +an interface definer could specify.
1.187 +@return TInt KErrNone for success.
1.188 + */
1.189 +TInt CImplementationClassTen::FireAndForget()
1.190 + {
1.191 + return KErrNone;
1.192 + }
1.193 +
1.194 +// Provide the CActive overloads
1.195 +void CImplementationClassTen::RunL()
1.196 + {
1.197 + // Do nothing : should never be called
1.198 + __ASSERT_DEBUG(EFalse,User::Invariant());
1.199 + }
1.200 +
1.201 +void CImplementationClassTen::DoCancel()
1.202 + {
1.203 + // Do nothing
1.204 + }
1.205 +
1.206 +TInt CImplementationClassTen::RunError(TInt /*aError*/)
1.207 + {
1.208 + return KErrNone;
1.209 + }
1.210 +
1.211 +/**
1.212 +To verify the object returned by ECOM.
1.213 +@return TUid (ECOM's Implementation Uid for this class.)
1.214 + */
1.215 +TUid CImplementationClassTen::ImplId()
1.216 + {
1.217 + return KImplUid1;
1.218 + }
1.219 +
1.220 +/**
1.221 +Extended interface method. Called to verify the Extended interface.
1.222 + */
1.223 +void CImplementationClassTen::DoMethodExtended()
1.224 + {
1.225 + //check the extended interface uid has been set properly
1.226 + ASSERT(iExtendedInterfaceUid.iUid == 0x10009E44);
1.227 + }
1.228 +
1.229 +/**
1.230 +Get the extended interface. This method will be called by ECOM, so the method must
1.231 +follow the signature defined by TProxyExtendedInterfaceGetPtrL. This must be a static
1.232 +method since it is used in the proxy table.
1.233 +@param aObject A pointer to the instantiation interface (CImplementationClassTen
1.234 + in this case) instance. This will be provided by ECOM. It must be provided
1.235 + as a parameter, as this method is a static method (and must be a static
1.236 + method because it is called by the proxy table).
1.237 +@param aExtendedInterface The extended interface to fetch. Must be a unique UID.
1.238 +@param aBitFlags Flags used for communication between plugin's and ECOM. Currently
1.239 + used to signal if an extended interface requires release.
1.240 +@param aReleaseObject return parameter, provides ECOM with the object to destroy
1.241 + if the interface requires to be released.
1.242 +@return TAny* a pointer to the fully constructed extended interface object
1.243 +*/
1.244 +TAny* CImplementationClassTen::GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& aReleaseObject)
1.245 +
1.246 + {
1.247 + //Initialise the release bit
1.248 + aBitFlags = aBitFlags & 0xFFFFFFFE;
1.249 + TAny* ret = NULL;
1.250 + switch (aExtendedInterface.iUid)
1.251 + {
1.252 + case 0x10009E44:
1.253 + {
1.254 + // No release is required, so do not modify aBitFlags.
1.255 + ret = static_cast<MExampleInterfaceExtended*>(static_cast<CImplementationClassTen*>(aObject));
1.256 + break;
1.257 + }
1.258 + case 0x10009E45:
1.259 + {
1.260 + // Indicate to caller that release is required
1.261 + aBitFlags = aBitFlags | KReleaseRequiredMask;
1.262 +
1.263 + CImplementationClassTenExtended *classExt = CImplementationClassTenExtended::NewL();
1.264 + // Must set the release object for ECOM to release later, this will not be the same as the interface object that is returned.
1.265 + aReleaseObject = classExt;
1.266 +
1.267 + ret = static_cast<MExampleInterfaceExtended2*>(classExt);
1.268 + break;
1.269 + }
1.270 + case 0x10009E46:
1.271 + {
1.272 + // Indicate to caller that release is required
1.273 + aBitFlags = aBitFlags | KReleaseRequiredMask;
1.274 +
1.275 + CImplementationClassTenExtended2 *classExt = CImplementationClassTenExtended2::NewL();
1.276 + // Must set the release object for ECOM to release later, this will not be the same as the interface object that is returned.
1.277 + aReleaseObject = classExt;
1.278 +
1.279 + ret = static_cast<MExampleInterfaceExtended2*>(classExt);
1.280 + break;
1.281 + }
1.282 + default:
1.283 + {
1.284 + break;
1.285 + }
1.286 + }
1.287 + return ret;
1.288 + }
1.289 +
1.290 +/**
1.291 +Release the specified extended interface. This method will be called by ECOM, so the method must
1.292 +follow the signature defined by TProxyExtendedInterfaceReleasePtr. This must be a static
1.293 +method since it is used in the proxy table.
1.294 +method.
1.295 +@param aReleaseObject provides ECOM with the object to destroy
1.296 + if the interface requires to be released.
1.297 +@param aExtendedInterface extended interface that is to be released
1.298 +@return TAny* a pointer to the fully constructed extended interface object
1.299 +*/
1.300 +void CImplementationClassTen::ReleaseExtendedInterface(TAny* aReleaseObject,const TUid& aExtendedInterface)
1.301 + {
1.302 + switch (aExtendedInterface.iUid)
1.303 + {
1.304 + case 0x10009E45:
1.305 + {
1.306 + // this object is an interface that was a separate object from the main instantiated object, and must be cleaned up.
1.307 + CImplementationClassTenExtended* classExt = static_cast<CImplementationClassTenExtended*>(aReleaseObject);
1.308 + delete classExt;
1.309 + break;
1.310 + }
1.311 + case 0x10009E46:
1.312 + {
1.313 + // this object is an interface that was a separate object from the main instantiated object, and must be cleaned up.
1.314 + CImplementationClassTenExtended2* classExt = static_cast<CImplementationClassTenExtended2*>(aReleaseObject);
1.315 + delete classExt;
1.316 + break;
1.317 + }
1.318 + default:
1.319 + {
1.320 + break;
1.321 + }
1.322 + }
1.323 + }
1.324 +
1.325 +
1.326 +// __________________________________________________________________________
1.327 +//
1.328 +// Implementation of CImplementationClassTenExtended
1.329 +
1.330 +/**
1.331 +Safe construction which leaves nothing upon the cleanup stack
1.332 +@return CImplementationClassTen* a pointer to the fully instantiated CImplementationClassTen object
1.333 +*/
1.334 +CImplementationClassTenExtended* CImplementationClassTenExtended::NewL()
1.335 +
1.336 + {
1.337 + CImplementationClassTenExtended* self=new(ELeave) CImplementationClassTenExtended();
1.338 + return self;
1.339 + }
1.340 +
1.341 +/**
1.342 +Destructor of CImplementationClassTenExtended
1.343 + */
1.344 +CImplementationClassTenExtended::~CImplementationClassTenExtended()
1.345 + {
1.346 + // do nothing
1.347 + }
1.348 +
1.349 +/**
1.350 +Default Constructor : usable only by derived classes
1.351 +*/
1.352 +CImplementationClassTenExtended::CImplementationClassTenExtended()
1.353 + {
1.354 + //set the extended interface uid
1.355 + iExtendedInterfaceUid.iUid = 0x10009E45;
1.356 + }
1.357 +
1.358 +/**
1.359 +Extended interface.
1.360 +*/
1.361 +void CImplementationClassTenExtended::DoMethodExtended2()
1.362 + {
1.363 + //check the extended interface uid has been set properly
1.364 + ASSERT(iExtendedInterfaceUid.iUid == 0x10009E45);
1.365 + }
1.366 +
1.367 +// __________________________________________________________________________
1.368 +//
1.369 +// Implementation of CImplementationClassTenExtended2
1.370 +
1.371 +/**
1.372 +Safe construction which leaves nothing upon the cleanup stack
1.373 +@return CImplementationClassTenExtended2* a pointer to the fully instantiated CImplementationClassTen object
1.374 +*/
1.375 +CImplementationClassTenExtended2* CImplementationClassTenExtended2::NewL()
1.376 + {
1.377 + CImplementationClassTenExtended2* self=new(ELeave) CImplementationClassTenExtended2();
1.378 + return self;
1.379 + }
1.380 +
1.381 +/**
1.382 +Destructor of CImplementationClassTenExtended2
1.383 + */
1.384 +CImplementationClassTenExtended2::~CImplementationClassTenExtended2()
1.385 + {
1.386 + // do nothing
1.387 + }
1.388 +
1.389 +/**
1.390 +Default Constructor : usable only by derived classes
1.391 +*/
1.392 +CImplementationClassTenExtended2::CImplementationClassTenExtended2()
1.393 + {
1.394 + //set the extended interface uid
1.395 + iExtendedInterfaceUid.iUid = 0x10009E46;
1.396 + }
1.397 +
1.398 +/**
1.399 +Extended interface.
1.400 +*/
1.401 +void CImplementationClassTenExtended2::DoMethodExtended2()
1.402 + {
1.403 + //check the extended interface uid has been set properly
1.404 + ASSERT(iExtendedInterfaceUid.iUid == 0x10009E46);
1.405 + }
1.406 +
1.407 +// CImplementationClassTenBasic implementation
1.408 +// ____________________________________________________________________________
1.409 +//
1.410 +/**
1.411 +This class implements the functionality promised by
1.412 +the CExampleInterface definition class. It does little apart from provides a test instance
1.413 +which may be retrieved and run for testing purposes. This is an example that no extended interface
1.414 +is implemented in this class.
1.415 +*/
1.416 +class CImplementationClassTenBasic : public CExampleInterface
1.417 +{
1.418 +// Methods
1.419 +public:
1.420 + static CImplementationClassTenBasic* NewL(TAny* aInitParams);
1.421 + virtual ~CImplementationClassTenBasic();
1.422 + void DoMethodL();
1.423 + TInt FireAndForget();
1.424 + TUid ImplId();
1.425 +private:
1.426 + CImplementationClassTenBasic();
1.427 + void ConstructL(TAny* aInitParams);
1.428 + // Provide the CActive overloads
1.429 + void RunL();
1.430 + void DoCancel();
1.431 + TInt RunError(TInt aError);
1.432 +private:
1.433 +/** A place for allocating some memory in the ConstructL */
1.434 + HBufC* iInternalDescriptor;
1.435 +/** An int to be stored in TLS to test its usage */
1.436 + TInt iTLSInt;
1.437 +
1.438 +}; // End of CImplementationClassTenBasic definition
1.439 +
1.440 +// __________________________________________________________________________
1.441 +// Implementation
1.442 +
1.443 +/**
1.444 +Safe construction which leaves nothing upon the cleanup stack
1.445 +@param aInitParams The parameter struct used for initialising this object
1.446 +@return CImplementationClassTenBasic* a pointer to the fully instantiated CImplementationClassTenBasic object
1.447 +*/
1.448 +CImplementationClassTenBasic* CImplementationClassTenBasic::NewL(TAny* aInitParams)
1.449 + {
1.450 + CImplementationClassTenBasic* self=new(ELeave) CImplementationClassTenBasic();
1.451 + CleanupStack::PushL(self);
1.452 + self->ConstructL(aInitParams);
1.453 + CleanupStack::Pop(self);
1.454 + return self;
1.455 + }
1.456 +
1.457 +/**
1.458 +Destructor of CImplementationClassTenBasic
1.459 + */
1.460 +CImplementationClassTenBasic::~CImplementationClassTenBasic()
1.461 + {
1.462 + delete iInternalDescriptor;
1.463 + Dll::FreeTls();
1.464 + }
1.465 +
1.466 +/**
1.467 +Default Constructor : usable only by derived classes
1.468 +*/
1.469 +CImplementationClassTenBasic::CImplementationClassTenBasic()
1.470 +: CExampleInterface()
1.471 + {
1.472 + }
1.473 +
1.474 +/**
1.475 +Completes the safe construction of the CImplementationClassTenBasic object
1.476 +@param aInitParams The parameter struct used for initialising this object
1.477 + */
1.478 +void CImplementationClassTenBasic::ConstructL(TAny* aInitParams)
1.479 + {
1.480 + TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*, aInitParams);
1.481 + if(params)
1.482 + {
1.483 + if(params->descriptor)
1.484 + {
1.485 + iInternalDescriptor = params->descriptor->AllocL();
1.486 + }
1.487 + }
1.488 +
1.489 + User::LeaveIfError(Dll::SetTls(&iTLSInt));
1.490 + }
1.491 +
1.492 +/**
1.493 +Overload of the pure interface method.Representative of a method provided on
1.494 +the interface by the interface definer.
1.495 + */
1.496 +void CImplementationClassTenBasic::DoMethodL()
1.497 + {
1.498 + // Access TLS to ensure it has been set properly
1.499 + ASSERT(Dll::Tls() != NULL);
1.500 + }
1.501 +
1.502 +/**
1.503 +Overload of the pure interface method asynchronous function which
1.504 +an interface definer could specify.
1.505 +@return TInt KErrNone for success.
1.506 + */
1.507 +TInt CImplementationClassTenBasic::FireAndForget()
1.508 + {
1.509 + return KErrNone;
1.510 + }
1.511 +
1.512 +// Provide the CActive overloads
1.513 +void CImplementationClassTenBasic::RunL()
1.514 + {
1.515 + // Do nothing : should never be called
1.516 + __ASSERT_DEBUG(EFalse,User::Invariant());
1.517 + }
1.518 +
1.519 +void CImplementationClassTenBasic::DoCancel()
1.520 + {
1.521 + // Do nothing
1.522 + }
1.523 +
1.524 +TInt CImplementationClassTenBasic::RunError(TInt /*aError*/)
1.525 + {
1.526 + return KErrNone;
1.527 + }
1.528 +
1.529 +/**
1.530 +To verify the object returned by ECOM.
1.531 +@return TUid (ECOM's Implementation Uid for this class.)
1.532 + */
1.533 +TUid CImplementationClassTenBasic::ImplId()
1.534 + {
1.535 + return KImplUid2;
1.536 + }
1.537 +
1.538 +// ____________________________________________________________________________
1.539 +//
1.540 +/**
1.541 +Intended usage: This class implements the functionality promised by
1.542 +the CExampleInterface defintion class. It does little apart from provides a test instance
1.543 +which may be retrieved and run for testing purposes.This is an example of
1.544 +how extended interface is implemented in the same class as the original.
1.545 + */
1.546 +class CImplementationClassTen2 : public CExampleInterface, public MExampleInterfaceExtended
1.547 +{
1.548 +// Methods
1.549 +public:
1.550 + static CImplementationClassTen2* NewL(TAny* aInitParams);
1.551 + virtual ~CImplementationClassTen2();
1.552 + void DoMethodL();
1.553 + TInt FireAndForget();
1.554 + TUid ImplId();
1.555 + static TAny* GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& aBitFlags,TAny*& releaseObject);
1.556 + public:
1.557 + virtual void DoMethodExtended(); // From MExampleInterfaceExtended
1.558 +private:
1.559 + CImplementationClassTen2();
1.560 + void ConstructL(TAny* aInitParams);
1.561 +// Provide the CActive overloads
1.562 + void RunL();
1.563 + void DoCancel();
1.564 + TInt RunError(TInt aError);
1.565 +private:
1.566 +/** A place for allocating some memory in the ConstructL */
1.567 + HBufC* iInternalDescriptor;
1.568 +/** An int to be stored in TLS to test its usage */
1.569 + TInt iTLSInt;
1.570 +/** Uid of the extended interface */
1.571 + TUid iExtendedInterfaceUid;
1.572 +}; // End of CImplementationClassTen2 definition
1.573 +
1.574 +// __________________________________________________________________________
1.575 +// Implementation
1.576 +
1.577 +/**
1.578 +Standardised safe construction which leaves nothing the cleanup stack.
1.579 +@param aInitParams The parameter struct used for initialising this object
1.580 +@return CImplementationClassTen2* The class instance.
1.581 + */
1.582 +CImplementationClassTen2* CImplementationClassTen2::NewL(TAny* aInitParams)
1.583 + {
1.584 + CImplementationClassTen2* self=new(ELeave) CImplementationClassTen2();
1.585 + CleanupStack::PushL(self);
1.586 + self->ConstructL(aInitParams);
1.587 + CleanupStack::Pop(self);
1.588 + return self;
1.589 + }
1.590 +/**
1.591 +Destructor of CImplementationClassTen2
1.592 + */
1.593 +CImplementationClassTen2::~CImplementationClassTen2()
1.594 + {
1.595 + delete iInternalDescriptor;
1.596 + Dll::FreeTls();
1.597 + }
1.598 +
1.599 +/**
1.600 +Default Constructor
1.601 +*/
1.602 +CImplementationClassTen2::CImplementationClassTen2()
1.603 +: CExampleInterface()
1.604 + {
1.605 + //set the extended interface uid
1.606 + iExtendedInterfaceUid.iUid = 0x10009E44;
1.607 + }
1.608 +
1.609 +/**
1.610 +Completes the safe construction of the CImplementationClassTenBasic object
1.611 +@param aInitParams The parameter struct used for initialising this object
1.612 + */
1.613 +void CImplementationClassTen2::ConstructL(TAny* aInitParams)
1.614 + {
1.615 + TExampleInterfaceInitParams* params = REINTERPRET_CAST(TExampleInterfaceInitParams*, aInitParams);
1.616 + if(params)
1.617 + {
1.618 + if(params->descriptor)
1.619 + {
1.620 + iInternalDescriptor = params->descriptor->AllocL();
1.621 + }
1.622 + }
1.623 + User::LeaveIfError(Dll::SetTls(&iTLSInt));
1.624 + }
1.625 +
1.626 +/**
1.627 +Overload of the pure interface method.Representative of a method provided on
1.628 +the interface by the interface definer.
1.629 + */
1.630 +void CImplementationClassTen2::DoMethodL()
1.631 + {
1.632 + // Access TLS to ensure it has been set properly
1.633 + ASSERT(Dll::Tls() != NULL);
1.634 + }
1.635 +
1.636 +/**
1.637 +Overload of the pure interface method asynchronous function which
1.638 +an interface definer could specify.
1.639 +@return TInt KErrNone for success.
1.640 + */
1.641 +TInt CImplementationClassTen2::FireAndForget()
1.642 + {
1.643 + return KErrNone;
1.644 + }
1.645 +
1.646 +// Provide the CActive overloads
1.647 +void CImplementationClassTen2::RunL()
1.648 + {
1.649 + // Do nothing : should never be called
1.650 + __ASSERT_DEBUG(EFalse,User::Invariant());
1.651 + }
1.652 +
1.653 +void CImplementationClassTen2::DoCancel()
1.654 + {
1.655 + // Do nothing
1.656 + }
1.657 +
1.658 +TInt CImplementationClassTen2::RunError(TInt /*aError*/)
1.659 + {
1.660 + return KErrNone;
1.661 + }
1.662 +
1.663 +/**
1.664 +To verify the object returned by ECOM.
1.665 +@return TUid (ECOM's Implementation Uid for this class.)
1.666 + */
1.667 +TUid CImplementationClassTen2::ImplId()
1.668 + {
1.669 + return KImplUid3;
1.670 + }
1.671 +
1.672 +/**
1.673 +Extended interface method. Called to verify the Extended interface.
1.674 + */
1.675 +void CImplementationClassTen2::DoMethodExtended()
1.676 + {
1.677 + //check the extended interface uid has been set properly
1.678 + ASSERT(iExtendedInterfaceUid.iUid == 0x10009E44);
1.679 + }
1.680 +
1.681 +/**
1.682 +Get the extended interface. This method will be called by ECOM, so the method must
1.683 +follow the signature defined by TProxyExtendedInterfaceGetPtrL.This must be a static
1.684 +method since it is used in the proxy table.
1.685 +@param aObject A pointer to the instantiation interface (CImplementationClassTen
1.686 + in this case) instance. This will be provided by ECOM. It must be provided
1.687 + as a parameter, as this method is a static method (and must be a static
1.688 + method because it is called by the proxy table).
1.689 +@param aExtendedInterface The extended interface to fetch. Must be a unique UID.
1.690 +@param aBitFlags Flags used for communication between plugin's and ECOM. Currently
1.691 + used to signal if an extended interface requires release.
1.692 +@param aReleaseObject return parameter, provides ECOM with the object to destroy
1.693 + if the interface requires to be released.
1.694 +@return TAny* a pointer to the fully constructed extended interface object
1.695 +*/
1.696 +TAny* CImplementationClassTen2::GetExtendedInterfaceL(TAny* aObject,const TUid& aExtendedInterface,TUint32& /*aBitFlags*/,TAny*& /*releaseObject*/)
1.697 + {
1.698 + TAny* ret = NULL;
1.699 + switch (aExtendedInterface.iUid)
1.700 + {
1.701 + case 0x10009E44:
1.702 + {
1.703 + // No release is required, so do not modify aBitFlags.
1.704 + ret = static_cast<MExampleInterfaceExtended*>(static_cast<CImplementationClassTen2*>(aObject));
1.705 + break;
1.706 + }
1.707 + default:
1.708 + {
1.709 + break;
1.710 + }
1.711 + }
1.712 + return ret;
1.713 + }
1.714 +
1.715 +// __________________________________________________________________________
1.716 +// Exported proxy for instantiation method resolution
1.717 +// Define the interface UIDs
1.718 +
1.719 +const TImplementationProxy3 KImplementationTable[] =
1.720 + {
1.721 + IMPLEMENTATION_PROXY_ENTRY3(0x10009E38,CImplementationClassTen::NewL,CImplementationClassTen::GetExtendedInterfaceL,CImplementationClassTen::ReleaseExtendedInterface),
1.722 + IMPLEMENTATION_PROXY_ENTRY3(0x10009E3A,CImplementationClassTenBasic::NewL,0,0),
1.723 + IMPLEMENTATION_PROXY_ENTRY3(0x10009E3B,CImplementationClassTen2::NewL,CImplementationClassTen2::GetExtendedInterfaceL,0)
1.724 + };
1.725 +
1.726 +EXPORT_C const TImplementationProxy3* ImplementationGroupProxy(TInt& aTableCount)
1.727 + {
1.728 + aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy3);
1.729 + return KImplementationTable;
1.730 + }