MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/lowlevellibsandfws/pluginfw/Framework/frame/Interface.inl
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains the placeholder class

    15 // which represents the interface creation.

    16 // 

    17 //

    18 

    19 /**

    20  @internalComponent

    21  @file

    22 */

    23 

    24 

    25 const TUid KCExampleInterfaceUid = {0x10009DC0};

    26 const TUid KCExample10InterfaceUid = {0x10009DBB};

    27 const TUid KCExtendedInterfaceUid1 = {0x10009E44};

    28 const TUid KCExtendedInterfaceUid2 = {0x10009E45};

    29 const TUid KCExtendedInterfaceUid3 = {0x10009E46};

    30 

    31 _LIT8(KImplementationTest,"text/wml");

    32 _LIT8(KImplementationTest10,"Example 10");

    33 

    34 inline CExampleInterface::CExampleInterface()

    35 : CActive(CActive::EPriorityLow)

    36 	{

    37 	// Do nothing

    38 	}

    39 

    40 

    41 inline CExampleInterface::~CExampleInterface()

    42 	{

    43 	Cancel();

    44 	// Destroy any instance variables and then

    45 	// inform the framework that this specific 

    46 	// instance of the interface has been destroyed.

    47 	REComSession::DestroyedImplementation(iDtor_ID_Key);

    48 	}

    49 

    50 

    51 inline CExampleInterface* CExampleInterface::NewL()

    52 	{

    53 	// Set up the interface find for the default resolver.

    54 	TEComResolverParams ResolverParams;

    55 	ResolverParams.SetDataType(KImplementationTest());

    56 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

    57 	TUid resolverUid = {0x10009DD0};

    58 

    59 	// Set up some empty initialisation parameters

    60 	TExampleInterfaceInitParams initParams;

    61 	initParams.integer		= 0;

    62 	initParams.descriptor	= NULL;

    63 

    64 	return REINTERPRET_CAST(CExampleInterface*, 

    65 							REComSession::CreateImplementationL(KCExampleInterfaceUid, 

    66 															   _FOFF(CExampleInterface,iDtor_ID_Key),

    67 															   &initParams,

    68 															   ResolverParams,

    69 															   resolverUid));

    70 	}

    71 

    72 inline CExampleInterface* CExampleInterface::NewL(const TDesC8& aMatchString)

    73 	{

    74 	// Set up the interface find for the default resolver.

    75 	TEComResolverParams ResolverParams;

    76 	ResolverParams.SetDataType(aMatchString);

    77 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

    78 

    79 	// Set up some empty initialisation parameters

    80 	TExampleInterfaceInitParams initParams;

    81 	initParams.integer		= 0;

    82 	initParams.descriptor	= NULL;

    83 

    84 	return REINTERPRET_CAST(CExampleInterface*, 

    85 							REComSession::CreateImplementationL(KCExampleInterfaceUid, 

    86 															   _FOFF(CExampleInterface,iDtor_ID_Key), 

    87 															   &initParams,

    88 															   ResolverParams));

    89 	}

    90 

    91 inline CExampleInterface* CExampleInterface::NewL(TInt aIntParameterTest, const TDesC& aDesParameterTest)

    92 	{

    93 	// Set up the interface find for the default resolver.

    94 	TEComResolverParams ResolverParams;

    95 	ResolverParams.SetDataType(KImplementationTest());

    96 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

    97 

    98 	// Set up the initialisation parameter passing

    99 	TExampleInterfaceInitParams initParams;

   100 	initParams.integer		= aIntParameterTest;

   101 	initParams.descriptor	= &aDesParameterTest;

   102 

   103 	// The CreateImplementationL method will return

   104 	// the created item.

   105 	return REINTERPRET_CAST(CExampleInterface*, REComSession::CreateImplementationL(KCExampleInterfaceUid,

   106 												_FOFF(CExampleInterface,iDtor_ID_Key),

   107 												&initParams,

   108 												ResolverParams));

   109 	}

   110 

   111 inline CExampleInterface* CExampleInterface::NewL2(const TUid aImplementationUid)

   112 	{

   113 	// Set up some empty initialisation parameters

   114 	TExampleInterfaceInitParams initParams;

   115 	initParams.integer		= 0;

   116 	initParams.descriptor	= NULL;

   117 	

   118 	// The CreateImplementationL method will return

   119 	// the created item.

   120 	return REINTERPRET_CAST(CExampleInterface*, 

   121 							REComSession::CreateImplementationL(aImplementationUid, 

   122 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   123 															   &initParams));

   124 	}

   125 

   126 inline CExampleInterface* CExampleInterface::NewL3()

   127 	{

   128 	// Set up the interface find for the default resolver.

   129 	TEComResolverParams ResolverParams;

   130 	ResolverParams.SetDataType(KImplementationTest());

   131 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   132 	

   133 	// Set up some empty initialisation parameters

   134 	TExampleInterfaceInitParams initParams;

   135 	initParams.integer		= 0;

   136 	initParams.descriptor	= NULL;

   137 

   138 	// The CreateImplementationL method will return

   139 	// the created item.

   140 	return REINTERPRET_CAST(CExampleInterface*, 

   141 							REComSession::CreateImplementationL(KCExampleInterfaceUid, 

   142 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   143 															   &initParams,

   144 															   ResolverParams));

   145 	}

   146 

   147 inline CExampleInterface* CExampleInterface::NewL4()

   148 	{

   149 	// Set up the interface find for the default resolver.

   150 	TEComResolverParams ResolverParams;

   151 	ResolverParams.SetDataType(KImplementationTest());

   152 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   153 	TUid resolverUid = {0x10009DD0};

   154 

   155 	// Set up some empty initialisation parameters

   156 	TExampleInterfaceInitParams initParams;

   157 	initParams.integer		= 0;

   158 	initParams.descriptor	= NULL;

   159 	

   160 	// The CreateImplementationL method will return

   161 	// the created item.

   162 	return REINTERPRET_CAST(CExampleInterface*, 

   163 							REComSession::CreateImplementationL(KCExampleInterfaceUid, 

   164 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   165 															   &initParams,

   166 															   ResolverParams,

   167 															   resolverUid));

   168 	}

   169 

   170 

   171 inline CExampleInterface* CExampleInterface::NewL5()

   172 	{

   173 	//set up extended interface;

   174 	RArray<TUid> extendedInterface;

   175 	CleanupClosePushL(extendedInterface);

   176 	extendedInterface.AppendL(KCExtendedInterfaceUid1);

   177 	extendedInterface.AppendL(KCExtendedInterfaceUid2);

   178 	extendedInterface.AppendL(KCExtendedInterfaceUid3);

   179 	

   180 	// Set up the interface find for the default resolver.

   181 	TEComResolverParams ResolverParams;

   182 	ResolverParams.SetDataType(KImplementationTest10());

   183 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   184 	

   185 	// The CreateImplementationL method will return the created item.

   186 	CExampleInterface* dll = REINTERPRET_CAST(CExampleInterface*, 

   187 							REComSession::CreateImplementationL(KCExample10InterfaceUid, 

   188 																extendedInterface,

   189 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   190 															   ResolverParams));

   191 	CleanupStack::PopAndDestroy(&extendedInterface);

   192 	return dll;															   

   193 	}

   194 

   195 

   196 inline CExampleInterface* CExampleInterface::NewL6()

   197 	{

   198 	//set up extended interface;

   199 	RArray<TUid> extendedInterface;

   200 	CleanupClosePushL(extendedInterface);

   201 	extendedInterface.AppendL(KCExtendedInterfaceUid1);

   202 	extendedInterface.AppendL(KCExtendedInterfaceUid2);

   203 	extendedInterface.AppendL(KCExtendedInterfaceUid3);

   204 	

   205 	// Set up the interface find for the default resolver.

   206 	TEComResolverParams ResolverParams;

   207 	ResolverParams.SetDataType(KImplementationTest10());

   208 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   209 	TUid resolverUid = {0x10009DD0};

   210 

   211 	// The CreateImplementationL method will return the created item.

   212 	CExampleInterface* dll = REINTERPRET_CAST(CExampleInterface*, 

   213 							REComSession::CreateImplementationL(KCExample10InterfaceUid, 

   214 																extendedInterface,

   215 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   216 															   ResolverParams,

   217 															   resolverUid));

   218 	CleanupStack::PopAndDestroy(&extendedInterface);

   219 	return dll;															   

   220 	}

   221 

   222 

   223 inline CExampleInterface* CExampleInterface::NewL7()

   224 	{

   225 	//set up extended interface;

   226 	RArray<TUid> extendedInterface;

   227 	CleanupClosePushL(extendedInterface);

   228 	extendedInterface.AppendL(KCExtendedInterfaceUid1);

   229 	extendedInterface.AppendL(KCExtendedInterfaceUid2);

   230 	extendedInterface.AppendL(KCExtendedInterfaceUid3);

   231 	

   232 	// Set up the interface find for the default resolver.

   233 	TEComResolverParams ResolverParams;

   234 	ResolverParams.SetDataType(KImplementationTest10());

   235 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   236 	

   237 	// Set up some empty initialisation parameters

   238 	TExampleInterfaceInitParams initParams;

   239 	initParams.integer		= 0;

   240 	initParams.descriptor	= NULL;

   241 

   242 	// The CreateImplementationL method will return the created item.

   243 	CExampleInterface* dll = REINTERPRET_CAST(CExampleInterface*, 

   244 							REComSession::CreateImplementationL(KCExample10InterfaceUid, 

   245 																extendedInterface,

   246 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   247 															   ResolverParams,

   248 															   &initParams));

   249 	CleanupStack::PopAndDestroy(&extendedInterface);

   250 	return dll;															   

   251 	}

   252 

   253 

   254 inline CExampleInterface* CExampleInterface::NewL8()

   255 	{

   256 	//set up extended interface;

   257 	RArray<TUid> extendedInterface;

   258 	CleanupClosePushL(extendedInterface);

   259 	extendedInterface.AppendL(KCExtendedInterfaceUid1);

   260 	extendedInterface.AppendL(KCExtendedInterfaceUid2);

   261 	extendedInterface.AppendL(KCExtendedInterfaceUid3);

   262 	

   263 	// Set up the interface find for the default resolver.

   264 	TEComResolverParams ResolverParams;

   265 	ResolverParams.SetDataType(KImplementationTest10());

   266 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   267 	TUid resolverUid = {0x10009DD0};

   268 

   269 	// Set up some empty initialisation parameters

   270 	TExampleInterfaceInitParams initParams;

   271 	initParams.integer		= 0;

   272 	initParams.descriptor	= NULL;

   273 

   274 	// The CreateImplementationL method will return the created item.

   275 	CExampleInterface* dll = REINTERPRET_CAST(CExampleInterface*, 

   276 							REComSession::CreateImplementationL(KCExample10InterfaceUid, 

   277 																extendedInterface,

   278 															   _FOFF(CExampleInterface,iDtor_ID_Key),

   279 															   ResolverParams,

   280 															   resolverUid,

   281 															   &initParams));

   282 	CleanupStack::PopAndDestroy(&extendedInterface);

   283 	return dll;															   

   284 	}

   285 

   286 

   287 	

   288 inline void CExampleInterface::ListImplementationsL(RImplInfoPtrArray& aImplInfoArray)

   289 	{

   290 	// Set up the interface find for the default resolver.

   291 	TEComResolverParams ResolverParams;

   292 	ResolverParams.SetDataType(KImplementationTest());

   293 	ResolverParams.SetWildcardMatch(ETrue);		// Allow wildcard matching

   294 

   295 	REComSession::ListImplementationsL(KCExampleInterfaceUid,

   296 									   ResolverParams, 

   297 									   aImplInfoArray);

   298 	}

   299 

   300 inline void CExampleInterface::ListAllImplementationsL(RImplInfoPtrArray& aImplInfoArray)

   301 	{

   302 	REComSession::ListImplementationsL(KCExampleInterfaceUid, aImplInfoArray);

   303 	}

   304 

   305 

   306 inline void CExampleInterface::DoMethodL()

   307 	{

   308 	User::Leave(KErrNotSupported);

   309 	}

   310 

   311 

   312 inline TInt CExampleInterface::FireAndForget()

   313 	{

   314 	return KErrNotSupported;

   315 	}

   316 

   317 inline TAny* CExampleInterface::GetExtendedInterfaceL(const TUid& aInterfaceUid)

   318 	{

   319 	TAny *object = NULL;

   320 	object = REComSession::GetExtendedInterfaceL(iDtor_ID_Key, aInterfaceUid);

   321 	return object;

   322 	}

   323 	

   324 inline void CExampleInterface::ManuallyReleaseExtendedInterfaceL(const TUid& aInterfaceUid)

   325 	{

   326 	REComSession::ManuallyReleaseExtendedInterfaceL(iDtor_ID_Key, aInterfaceUid);

   327 	}
Symaptic