1 // Copyright (c) 2007-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 // Implementation of list retrieval helpers classes

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 #include "listretrievalhelpers.h"

    22 #include <mmretrieve.h>

    23 #include <etelmm.h>

    24 

    25 //Canceller class definition

    26 CTestCanceller::CTestCanceller(CActive* aRetrieve) :

    27 CAsyncOneShot(EPriorityNormal), iRetrieve(aRetrieve)

    28 	{

    29 	}

    30 	

    31 CTestCanceller::~CTestCanceller()

    32 	{

    33 	}

    34 	

    35 void CTestCanceller::ConstructL()

    36 	{

    37 	}

    38 	

    39 void CTestCanceller::RunL()

    40 	{

    41 	iRetrieve->Cancel();

    42 	CActiveScheduler::Stop();

    43 	};

    44 	

    45 //CRetrieveListHelperBase class definition

    46 template<class TRetriever, class TList, class TSubSess>

    47 CRetrieveListHelperBase<TRetriever, TList, TSubSess>::~CRetrieveListHelperBase()

    48 	{

    49 	if(iRetrieve)

    50 		{

    51 		iRetrieve->Cancel();

    52 		}

    53 	delete iList;

    54 	delete iRetrieve;

    55 	delete iCanceller;

    56 	delete iScheduler;

    57 	}

    58 	

    59 template<class TRetriever, class TList, class TSubSess>

    60 CRetrieveListHelperBase<TRetriever, TList, TSubSess>::CRetrieveListHelperBase(TSubSess& aSubSess) :

    61 	CActive(EPriorityNormal), iSubSess(aSubSess)

    62 	{

    63 	}

    64 

    65 template<class TRetriever, class TList, class TSubSess>

    66 void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::ConstructL()

    67 	{

    68 	//create scheduler if not already present

    69 	if(!CActiveScheduler::Current())

    70 		{

    71 		iScheduler = new(ELeave) CActiveScheduler;

    72     	CActiveScheduler::Install(iScheduler);

    73 		}

    74 	CreateEtelRetrieverL();

    75 	iCanceller = new (ELeave) CTestCanceller(this);

    76 	CActiveScheduler::Add(this);

    77 	}

    78 

    79 

    80 

    81 template<class TRetriever, class TList, class TSubSess>

    82 void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::RunL()

    83 	{

    84     CActiveScheduler::Stop();

    85 	}

    86 

    87 template<class TRetriever, class TList, class TSubSess>

    88 void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::DoCancel()

    89 	{

    90 	iRetrieve->Cancel();

    91 	}

    92 	

    93 

    94 	

    95 //

    96 //Definitions for concrete implementations of CRetrieveListHelper//

    97 

    98 //CRetrieveMobilePhoneDetectedNetworksHelper

    99 CRetrieveListHelperBase<CRetrieveMobilePhoneDetectedNetworks, CMobilePhoneNetworkList, RMobilePhone>* CRetrieveMobilePhoneDetectedNetworksHelper::NewL(RMobilePhone& aPhone,TListVersion aListNumber)

   100 	{

   101 	CRetrieveMobilePhoneDetectedNetworksHelper* self = new (ELeave) CRetrieveMobilePhoneDetectedNetworksHelper(aPhone,aListNumber);

   102 	CleanupStack::PushL(self);

   103 	self->ConstructL();

   104 	CleanupStack::Pop();

   105 	return self;

   106 	}

   107 	

   108 CRetrieveMobilePhoneDetectedNetworksHelper::CRetrieveMobilePhoneDetectedNetworksHelper(RMobilePhone& aSess,TListVersion aListNumber)

   109 : CRetrieveListHelperBase<CRetrieveMobilePhoneDetectedNetworks, CMobilePhoneNetworkList, RMobilePhone>(aSess), iListVersionToRetrieve(aListNumber)

   110 	{	

   111 	}

   112 

   113 void CRetrieveMobilePhoneDetectedNetworksHelper::CreateEtelRetrieverL()

   114 	{

   115 	//create etelmm list retrieval object

   116 	iRetrieve = CRetrieveMobilePhoneDetectedNetworks::NewL(iSubSess);

   117 	}

   118 	

   119 void CRetrieveMobilePhoneDetectedNetworksHelper::StartListRetrieval()

   120 	{

   121 		switch(iListVersionToRetrieve)

   122 		{

   123 			case ERetrieveListV1:

   124 			{

   125 				iRetrieve->Start(iStatus);

   126 				break;		

   127 			}

   128 			case ERetrieveListV2:

   129 			{

   130 				iRetrieve->StartV2(iStatus);

   131 				break;	

   132 			}

   133 			case ERetrieveListV5:

   134 			{

   135 				iRetrieve->StartV5(iStatus);

   136 				break;	

   137 			}

   138 		}

   139 		

   140 	}

   141 	

   142 TAny* CRetrieveMobilePhoneDetectedNetworksHelper::GetListL()

   143 	{

   144 		switch(iListVersionToRetrieve)

   145 			{

   146 			case ERetrieveListV1:

   147 				{

   148 				return iRetrieve->RetrieveListL();

   149 				}

   150 			case ERetrieveListV2:

   151 				{

   152 				return iRetrieve->RetrieveListV2L();

   153 				}

   154 			case ERetrieveListV5:

   155 				{

   156 				return iRetrieve->RetrieveListV5L();

   157 				}

   158 			default:

   159 				{

   160 				_LIT(KErrorLitText,"Wrong argument was entered by user");

   161 				User::Panic(KErrorLitText, KErrArgument); // Attempting to retrieve a non-existant version of the list.

   162 				break;

   163 				}

   164 			}

   165 		return NULL;

   166 

   167 	}	

   168 //

   169 

   170 //CRetrieveMobilePhoneSmsListHelper	

   171 CRetrieveMobilePhoneSmsListExec* CRetrieveMobilePhoneSmsListHelper::NewL(RMobilePhoneStore& aSubSess, TInt aStartIndex, TInt aBatchSize)

   172 	{

   173 	CRetrieveMobilePhoneSmsListHelper* self = new (ELeave) CRetrieveMobilePhoneSmsListHelper(aSubSess, aStartIndex, aBatchSize);

   174 	CleanupStack::PushL(self);

   175 	self->ConstructL();

   176 	CleanupStack::Pop();

   177 	return self;

   178 	}

   179 	

   180 CRetrieveMobilePhoneSmsListHelper::CRetrieveMobilePhoneSmsListHelper(RMobilePhoneStore& aSubSess, TInt aStartIndex, TInt aBatchSize)

   181 : CRetrieveListHelperBase<CRetrieveMobilePhoneSmsList, CMobilePhoneGsmSmsList, RMobilePhoneStore>(aSubSess), iStartIndex(aStartIndex), iBatchSize(aBatchSize)

   182 	{	

   183 	}

   184 

   185 void CRetrieveMobilePhoneSmsListHelper::CreateEtelRetrieverL()

   186 	{

   187 	//create etelmm list retrieval object

   188 	iRetrieve = CRetrieveMobilePhoneSmsList::NewL(iSubSess, RMobileSmsStore::KETelMobileGsmSmsEntryV1);

   189 	}

   190 	

   191 void CRetrieveMobilePhoneSmsListHelper::StartListRetrieval()

   192 	{

   193 	if(iStartIndex == -1 || iBatchSize == -1)

   194 		iRetrieve->Start(iStatus);

   195 	else

   196 		iRetrieve->StartBatch(iStatus, iStartIndex,iBatchSize);

   197 	}

   198 	

   199 TAny* CRetrieveMobilePhoneSmsListHelper::GetListL()

   200 	{

   201 	return iRetrieve->RetrieveGsmListL();

   202 	}

   203 

   204 //

   205 //CRetrieveMobilePhoneCFListHelper

   206 CRetrieveListHelperBase<CRetrieveMobilePhoneCFList, CMobilePhoneCFList, RMobilePhone>* CRetrieveMobilePhoneCFListHelper::NewL(RMobilePhone& aPhone, RMobilePhone::TMobilePhoneCFCondition aCondition, RMobilePhone::TMobileService aServiceGroup, RMobilePhone::TMobileInfoLocation aLocation)

   207 	{

   208 	CRetrieveMobilePhoneCFListHelper* self = new (ELeave) CRetrieveMobilePhoneCFListHelper(aPhone, aCondition, aServiceGroup, aLocation);

   209 	CleanupStack::PushL(self);

   210 	self->ConstructL();

   211 	CleanupStack::Pop();

   212 	return self;

   213 	}

   214 	

   215 CRetrieveMobilePhoneCFListHelper::CRetrieveMobilePhoneCFListHelper(RMobilePhone& aSess, RMobilePhone::TMobilePhoneCFCondition aCondition, RMobilePhone::TMobileService aServiceGroup,RMobilePhone::TMobileInfoLocation aLocation)

   216 : CRetrieveListHelperBase<CRetrieveMobilePhoneCFList, CMobilePhoneCFList, RMobilePhone>(aSess), iCondition(aCondition), iServiceGroup(aServiceGroup), iLocation(aLocation)

   217 	{	

   218 	}

   219 

   220 void CRetrieveMobilePhoneCFListHelper::CreateEtelRetrieverL()

   221 	{

   222 	//create etelmm list retrieval object

   223 	iRetrieve = CRetrieveMobilePhoneCFList::NewL(iSubSess);

   224 	}

   225 	

   226 void CRetrieveMobilePhoneCFListHelper::StartListRetrieval()

   227 	{

   228 	iRetrieve->Start(iStatus, iCondition, iServiceGroup, iLocation);

   229 	}

   230 	

   231 TAny* CRetrieveMobilePhoneCFListHelper::GetListL()

   232 	{

   233 	return iRetrieve->RetrieveListL();

   234 	}

   235 //

   236 //CRetrieveMobilePhoneCBListHelper

   237 CRetrieveListHelperBase<CRetrieveMobilePhoneCBList, CMobilePhoneCBList, RMobilePhone>* CRetrieveMobilePhoneCBListHelper::NewL(RMobilePhone& aPhone, RMobilePhone::TMobilePhoneCBCondition aCondition,RMobilePhone::TMobileInfoLocation aLocation)

   238 	{

   239 	CRetrieveMobilePhoneCBListHelper* self = new (ELeave) CRetrieveMobilePhoneCBListHelper(aPhone, aCondition,aLocation);

   240 	CleanupStack::PushL(self);

   241 	self->ConstructL();

   242 	CleanupStack::Pop();

   243 	return self;

   244 	}

   245 	

   246 CRetrieveMobilePhoneCBListHelper::CRetrieveMobilePhoneCBListHelper(RMobilePhone& aSess, RMobilePhone::TMobilePhoneCBCondition aCondition, RMobilePhone::TMobileInfoLocation aLocation)

   247 : CRetrieveListHelperBase<CRetrieveMobilePhoneCBList, CMobilePhoneCBList, RMobilePhone>(aSess), iCondition(aCondition),iLocation(aLocation)

   248 	{	

   249 	}

   250 

   251 void CRetrieveMobilePhoneCBListHelper::CreateEtelRetrieverL()

   252 	{

   253 	//create etelmm list retrieval object

   254 	iRetrieve = CRetrieveMobilePhoneCBList::NewL(iSubSess);

   255 	}

   256 	

   257 void CRetrieveMobilePhoneCBListHelper::StartListRetrieval()

   258 	{

   259 	iRetrieve->Start(iStatus, iCondition, iLocation);

   260 	}

   261 	

   262 TAny* CRetrieveMobilePhoneCBListHelper::GetListL()

   263 	{

   264 	return iRetrieve->RetrieveListL();

   265 	}

   266 

   267 //

   268 //Definitions for concrete implementations of CRetrieveListHelper//

   269 

   270 //CRetrieveMobilePhoneCWListHelper

   271 CRetrieveListHelperBase<CRetrieveMobilePhoneCWList, CMobilePhoneCWList, RMobilePhone>* CRetrieveMobilePhoneCWListHelper::NewL(RMobilePhone& aPhone)

   272 	{

   273 	CRetrieveMobilePhoneCWListHelper* self = new (ELeave) CRetrieveMobilePhoneCWListHelper(aPhone);

   274 	CleanupStack::PushL(self);

   275 	self->ConstructL();

   276 	CleanupStack::Pop();

   277 	return self;

   278 	}

   279 	

   280 CRetrieveMobilePhoneCWListHelper::CRetrieveMobilePhoneCWListHelper(RMobilePhone& aSess)

   281 : CRetrieveListHelperBase<CRetrieveMobilePhoneCWList, CMobilePhoneCWList, RMobilePhone>(aSess)

   282 	{	

   283 	}

   284 

   285 void CRetrieveMobilePhoneCWListHelper::CreateEtelRetrieverL()

   286 	{

   287 	//create etelmm list retrieval object

   288 	iRetrieve = CRetrieveMobilePhoneCWList::NewL(iSubSess);

   289 	}

   290 	

   291 void CRetrieveMobilePhoneCWListHelper::StartListRetrieval()

   292 	{

   293 	iRetrieve->Start(iStatus);

   294 	}

   295 	

   296 TAny* CRetrieveMobilePhoneCWListHelper::GetListL()

   297 	{

   298 	return iRetrieve->RetrieveListL();

   299 	}	

   300 

   301 //

   302 //Definitions for concrete implementations of CRetrieveListHelper//

   303 

   304 //CRetrieveMobilePhoneCcbsListHelper

   305 CRetrieveListHelperBase<CRetrieveMobilePhoneCcbsList, CMobilePhoneCcbsList, RMobilePhone>* CRetrieveMobilePhoneCcbsListHelper::NewL(RMobilePhone& aPhone)

   306 	{

   307 	CRetrieveMobilePhoneCcbsListHelper* self = new (ELeave) CRetrieveMobilePhoneCcbsListHelper(aPhone);

   308 	CleanupStack::PushL(self);

   309 	self->ConstructL();

   310 	CleanupStack::Pop();

   311 	return self;

   312 	}

   313 	

   314 CRetrieveMobilePhoneCcbsListHelper::CRetrieveMobilePhoneCcbsListHelper(RMobilePhone& aSess)

   315 : CRetrieveListHelperBase<CRetrieveMobilePhoneCcbsList, CMobilePhoneCcbsList, RMobilePhone>(aSess)

   316 	{	

   317 	}

   318 

   319 void CRetrieveMobilePhoneCcbsListHelper::CreateEtelRetrieverL()

   320 	{

   321 	//create etelmm list retrieval object

   322 	iRetrieve = CRetrieveMobilePhoneCcbsList::NewL(iSubSess);

   323 	}

   324 	

   325 void CRetrieveMobilePhoneCcbsListHelper::StartListRetrieval()

   326 	{

   327 	iRetrieve->Start(iStatus);

   328 	}

   329 	

   330 TAny* CRetrieveMobilePhoneCcbsListHelper::GetListL()

   331 	{

   332 	return iRetrieve->RetrieveListL();

   333 	}	

   334 

   335 

   336 //

   337 //Definitions for concrete implementations of CRetrieveListHelper//

   338 

   339 //CRetrieveMobilePhoneSmspListHelper

   340 CRetrieveListHelperBase<CRetrieveMobilePhoneSmspList, CMobilePhoneSmspList, RMobileSmsMessaging>* CRetrieveMobilePhoneSmspListHelper::NewL(RMobileSmsMessaging& aPhone)

   341 	{

   342 	CRetrieveMobilePhoneSmspListHelper* self = new (ELeave) CRetrieveMobilePhoneSmspListHelper(aPhone);

   343 	CleanupStack::PushL(self);

   344 	self->ConstructL();

   345 	CleanupStack::Pop();

   346 	return self;

   347 	}

   348 	

   349 CRetrieveMobilePhoneSmspListHelper::CRetrieveMobilePhoneSmspListHelper(RMobileSmsMessaging& aSess)

   350 : CRetrieveListHelperBase<CRetrieveMobilePhoneSmspList, CMobilePhoneSmspList, RMobileSmsMessaging>(aSess)

   351 	{	

   352 	}

   353 

   354 void CRetrieveMobilePhoneSmspListHelper::CreateEtelRetrieverL()

   355 	{

   356 	//create etelmm list retrieval object

   357 	iRetrieve = CRetrieveMobilePhoneSmspList::NewL(iSubSess);

   358 	}

   359 	

   360 void CRetrieveMobilePhoneSmspListHelper::StartListRetrieval()

   361 	{

   362 	iRetrieve->Start(iStatus);

   363 	}

   364 	

   365 TAny* CRetrieveMobilePhoneSmspListHelper::GetListL()

   366 	{

   367 	return iRetrieve->RetrieveListL();

   368 	}	

   369 //

   370 

   371 //

   372 //Definitions for concrete implementations of CRetrieveListHelper//

   373 

   374 //CRetrieveMobilePhoneBroadcastIdListHelper

   375 CRetrieveListHelperBase<CRetrieveMobilePhoneBroadcastIdList, CMobilePhoneBroadcastIdList, RMobileBroadcastMessaging>* CRetrieveMobilePhoneBroadcastIdListHelper::NewL(RMobileBroadcastMessaging& aPhone,RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType)

   376 	{

   377 	CRetrieveMobilePhoneBroadcastIdListHelper* self = new (ELeave) CRetrieveMobilePhoneBroadcastIdListHelper(aPhone, aIdType);

   378 	CleanupStack::PushL(self);

   379 	self->ConstructL();

   380 	CleanupStack::Pop();

   381 	return self;

   382 	}

   383 	

   384 CRetrieveMobilePhoneBroadcastIdListHelper::CRetrieveMobilePhoneBroadcastIdListHelper(RMobileBroadcastMessaging& aSess, RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType)

   385 : CRetrieveListHelperBase<CRetrieveMobilePhoneBroadcastIdList, CMobilePhoneBroadcastIdList, RMobileBroadcastMessaging>(aSess), iIdType(aIdType)

   386 	{	

   387 	}

   388 

   389 void CRetrieveMobilePhoneBroadcastIdListHelper::CreateEtelRetrieverL()

   390 	{

   391 	//create etelmm list retrieval object

   392 	iRetrieve = CRetrieveMobilePhoneBroadcastIdList::NewL(iSubSess);

   393 	}

   394 	

   395 void CRetrieveMobilePhoneBroadcastIdListHelper::StartListRetrieval()

   396 	{

   397 	iRetrieve->Start(iStatus,iIdType);

   398 	}

   399 	

   400 TAny* CRetrieveMobilePhoneBroadcastIdListHelper::GetListL()

   401 	{

   402 	return iRetrieve->RetrieveListL();

   403 	}	

   404 //

   405 

   406 

   407 //

   408 //Definitions for concrete implementations of CRetrieveListHelper//

   409 

   410 //CRetrieveMobilePhoneNamListHelper

   411 CRetrieveListHelperBase<CRetrieveMobilePhoneNamList, CMobilePhoneNamList, RMobilePhoneStore>* CRetrieveMobilePhoneNamListHelper::NewL(RMobilePhoneStore& aPhone,TInt aNamId, TListVersion aNamList)

   412 	{

   413 	CRetrieveMobilePhoneNamListHelper* self = new (ELeave) CRetrieveMobilePhoneNamListHelper(aPhone, aNamId, aNamList);

   414 	CleanupStack::PushL(self);

   415 	self->ConstructL();

   416 	CleanupStack::Pop();

   417 	return self;

   418 	}

   419 	

   420 CRetrieveMobilePhoneNamListHelper::CRetrieveMobilePhoneNamListHelper(RMobilePhoneStore& aSess, TInt aNamId,TListVersion aNamList)

   421 : CRetrieveListHelperBase<CRetrieveMobilePhoneNamList, CMobilePhoneNamList, RMobilePhoneStore>(aSess), iNamId(aNamId), iListVersionToRetrieve(aNamList)

   422 	{	

   423 	}

   424 

   425 void CRetrieveMobilePhoneNamListHelper::CreateEtelRetrieverL()

   426 	{

   427 	//create etelmm list retrieval object

   428 	iRetrieve = CRetrieveMobilePhoneNamList::NewL(iSubSess);

   429 	}

   430 	

   431 	

   432 void CRetrieveMobilePhoneNamListHelper::StartListRetrieval()

   433 	{

   434 		switch(iListVersionToRetrieve)

   435 			{

   436 			case ERetrieveListV1:

   437 				{

   438 				iRetrieve->Start(iStatus,iNamId);

   439 				break;		

   440 				}

   441 			case ERetrieveListV4:

   442 				{

   443 				iRetrieve->StartV4(iStatus,iNamId);

   444 				break;	

   445 				}

   446 			

   447 			}

   448 	}

   449 	

   450 TAny* CRetrieveMobilePhoneNamListHelper::GetListL()

   451 	{

   452 	switch(iListVersionToRetrieve)

   453 		{

   454 			case ERetrieveListV1:

   455 				{

   456 				return iRetrieve->RetrieveListL();

   457 				}

   458 			case ERetrieveListV4:

   459 				{

   460 				return iRetrieve->RetrieveListV4L();

   461 				}

   462 			default:

   463 				{

   464 				_LIT(KErrorLitText,"Wrong argument was entered by user");

   465 				User::Panic(KErrorLitText, KErrArgument); // Attempting to retrieve a non-existant version of the list.

   466 				break;

   467 				}

   468 		}

   469 	return NULL;

   470 	

   471 	}	

   472 //

   473 

   474 

   475 //

   476 //Definitions for concrete implementations of CRetrieveListHelper//

   477 

   478 //CRetrieveMobilePhoneONListHelper

   479 CRetrieveListHelperBase<CRetrieveMobilePhoneONList, CMobilePhoneONList, RMobilePhoneStore>* CRetrieveMobilePhoneONListHelper::NewL(RMobilePhoneStore& aPhone)

   480 	{

   481 	CRetrieveMobilePhoneONListHelper* self = new (ELeave) CRetrieveMobilePhoneONListHelper(aPhone);

   482 	CleanupStack::PushL(self);

   483 	self->ConstructL();

   484 	CleanupStack::Pop();

   485 	return self;

   486 	}

   487 	

   488 CRetrieveMobilePhoneONListHelper::CRetrieveMobilePhoneONListHelper(RMobilePhoneStore& aSess)

   489 : CRetrieveListHelperBase<CRetrieveMobilePhoneONList, CMobilePhoneONList, RMobilePhoneStore>(aSess)

   490 	{	

   491 	}

   492 

   493 void CRetrieveMobilePhoneONListHelper::CreateEtelRetrieverL()

   494 	{

   495 	//create etelmm list retrieval object

   496 	iRetrieve = CRetrieveMobilePhoneONList::NewL(iSubSess);

   497 	}

   498 	

   499 void CRetrieveMobilePhoneONListHelper::StartListRetrieval()

   500 	{

   501 	iRetrieve->Start(iStatus);

   502 	}

   503 	

   504 TAny* CRetrieveMobilePhoneONListHelper::GetListL()

   505 	{

   506 	return iRetrieve->RetrieveListL();

   507 	}	

   508 //

   509 

   510 

   511 //

   512 //Definitions for concrete implementations of CRetrieveListHelper//

   513 

   514 //CRetrieveMobilePhoneENListHelper

   515 CRetrieveListHelperBase<CRetrieveMobilePhoneENList, CMobilePhoneENList, RMobilePhoneStore>* CRetrieveMobilePhoneENListHelper::NewL(RMobilePhoneStore& aPhone)

   516 	{

   517 	CRetrieveMobilePhoneENListHelper* self = new (ELeave) CRetrieveMobilePhoneENListHelper(aPhone);

   518 	CleanupStack::PushL(self);

   519 	self->ConstructL();

   520 	CleanupStack::Pop();

   521 	return self;

   522 	}

   523 	

   524 CRetrieveMobilePhoneENListHelper::CRetrieveMobilePhoneENListHelper(RMobilePhoneStore& aSess)

   525 : CRetrieveListHelperBase<CRetrieveMobilePhoneENList, CMobilePhoneENList, RMobilePhoneStore>(aSess)

   526 	{	

   527 	}

   528 

   529 void CRetrieveMobilePhoneENListHelper::CreateEtelRetrieverL()

   530 	{

   531 	//create etelmm list retrieval object

   532 	iRetrieve = CRetrieveMobilePhoneENList::NewL(iSubSess);

   533 	}

   534 	

   535 void CRetrieveMobilePhoneENListHelper::StartListRetrieval()

   536 	{

   537 	iRetrieve->Start(iStatus);

   538 	}

   539 	

   540 TAny* CRetrieveMobilePhoneENListHelper::GetListL()

   541 	{

   542 	return iRetrieve->RetrieveListL();

   543 	}	

   544 //

   545 

   546 //Definitions for concrete implementations of CRetrieveListHelper//

   547 

   548 //CRetrieveMobilePhonePreferredNetworksHelper

   549 CRetrieveListHelperBase<CRetrieveMobilePhonePreferredNetworks, CMobilePhoneStoredNetworkList, RMobilePhone>* CRetrieveMobilePhonePreferredNetworksHelper::NewL(RMobilePhone& aPhone)

   550 	{

   551 	CRetrieveMobilePhonePreferredNetworksHelper* self = new (ELeave) CRetrieveMobilePhonePreferredNetworksHelper(aPhone);

   552 	CleanupStack::PushL(self);

   553 	self->ConstructL();

   554 	CleanupStack::Pop();

   555 	return self;

   556 	}

   557 	

   558 CRetrieveMobilePhonePreferredNetworksHelper::CRetrieveMobilePhonePreferredNetworksHelper(RMobilePhone& aSess)

   559 : CRetrieveListHelperBase<CRetrieveMobilePhonePreferredNetworks, CMobilePhoneStoredNetworkList, RMobilePhone>(aSess)

   560 	{	

   561 	}

   562 

   563 void CRetrieveMobilePhonePreferredNetworksHelper::CreateEtelRetrieverL()

   564 	{

   565 	//create etelmm list retrieval object

   566 	iRetrieve = CRetrieveMobilePhonePreferredNetworks::NewL(iSubSess);

   567 	}

   568 	

   569 void CRetrieveMobilePhonePreferredNetworksHelper::StartListRetrieval()

   570 	{

   571 	iRetrieve->Start(iStatus);

   572 	}

   573 	

   574 TAny* CRetrieveMobilePhonePreferredNetworksHelper::GetListL()

   575 	{

   576 	return iRetrieve->RetrieveListL();

   577 	}	

   578 //