telephonyserverplugins/common_tsy/test/integration/src/cetelnotifycleanup.cpp
changeset 0 3553901f7fa8
child 24 6638e7f4bd8f
equal deleted inserted replaced
-1:000000000000 0:3553901f7fa8
       
     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 // This file contains methods for resetting the notifier queues on the etel server
       
    15 // at the end of a test
       
    16 // 
       
    17 //
       
    18 
       
    19 /**
       
    20  @file 
       
    21 */
       
    22  
       
    23 #include "cetelsessionmgr.h"
       
    24 #include "cctsytestlogging.h"
       
    25 #include "pcktcs.h"
       
    26 #include "e32debug.h"
       
    27 
       
    28 //
       
    29 //Cleanup methods
       
    30 //
       
    31 /**
       
    32 * Notify cleanup for RMobileBroadcastMessaging::NotifyBroadcastIdListChange
       
    33 */	
       
    34 void CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyBroadcastIdListChange( 
       
    35 					RMobileBroadcastMessaging& aMobileBroadcastMessaging )
       
    36 
       
    37 	{
       
    38 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyBroadcastIdListChange"));
       
    39 	TRequestStatus reqStatus;
       
    40 	do 
       
    41 		{
       
    42 		aMobileBroadcastMessaging.NotifyBroadcastIdListChange(reqStatus);
       
    43 		aMobileBroadcastMessaging.CancelAsyncRequest(EMobileBroadcastMessagingNotifyIdListChange);
       
    44 		User::WaitForRequest( reqStatus );
       
    45 		}
       
    46 	while( KErrNone == reqStatus.Int() );
       
    47 	}
       
    48 
       
    49 		
       
    50 /**
       
    51 * Notify cleanup for RMobileBroadcastMessaging::NotifyFilterSettingChange
       
    52 */	
       
    53 void CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyFilterSettingChange( 
       
    54 					RMobileBroadcastMessaging& aMobileBroadcastMessaging )
       
    55 
       
    56 	{
       
    57 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyFilterSettingChange"));
       
    58 	TRequestStatus reqStatus;
       
    59 	RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter setting;
       
    60 	do 
       
    61 		{
       
    62 		aMobileBroadcastMessaging.NotifyFilterSettingChange(reqStatus,setting);
       
    63 		aMobileBroadcastMessaging.CancelAsyncRequest(EMobileBroadcastMessagingNotifyFilterSettingChange);
       
    64 		User::WaitForRequest( reqStatus );
       
    65 		}
       
    66 	while( KErrNone == reqStatus.Int() );
       
    67 	}
       
    68 
       
    69 		
       
    70 /**
       
    71 * Notify cleanup for RMobileBroadcastMessaging::NotifyLanguageFilterChange
       
    72 */	
       
    73 void CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyLanguageFilterChange( 
       
    74 					RMobileBroadcastMessaging& aMobileBroadcastMessaging )
       
    75 
       
    76 	{
       
    77 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifyLanguageFilterChange"));
       
    78 	TRequestStatus reqStatus;
       
    79 	TBuf16<16> langFilter;
       
    80 	do 
       
    81 		{
       
    82 		aMobileBroadcastMessaging.NotifyLanguageFilterChange(reqStatus,langFilter);
       
    83 		aMobileBroadcastMessaging.CancelAsyncRequest(EMobileBroadcastMessagingNotifyLanguageFilterChange);
       
    84 		User::WaitForRequest( reqStatus );
       
    85 		}
       
    86 	while( KErrNone == reqStatus.Int() );
       
    87 	}
       
    88 
       
    89 		
       
    90 /**
       
    91 * Notify cleanup for RMobileLine::NotifyMobileLineStatusChange
       
    92 */	
       
    93 void CEtelSessionMgr::CleanupMobileLineNotifyMobileLineStatusChange( 
       
    94 					RMobileLine& aMobileLine )
       
    95 
       
    96 	{
       
    97 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileLineNotifyMobileLineStatusChange"));
       
    98 	TRequestStatus reqStatus;
       
    99 	RMobileCall::TMobileCallStatus status;
       
   100 	do 
       
   101 		{
       
   102 		aMobileLine.NotifyMobileLineStatusChange(reqStatus,status);
       
   103 		aMobileLine.CancelAsyncRequest(EMobileLineNotifyMobileLineStatusChange);
       
   104 		User::WaitForRequest( reqStatus );
       
   105 		}
       
   106 	while( KErrNone == reqStatus.Int() );
       
   107 	}
       
   108 
       
   109 		
       
   110 /**
       
   111 * Notify cleanup for RMobilePhone::NotifyALSLineChange
       
   112 */	
       
   113 void CEtelSessionMgr::CleanupMobilePhoneNotifyALSLineChange( 
       
   114 					RMobilePhone& aMobilePhone )
       
   115 
       
   116 	{
       
   117 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyALSLineChange"));
       
   118 	TRequestStatus reqStatus;
       
   119 	RMobilePhone::TMobilePhoneALSLine aLSLine;
       
   120 	do 
       
   121 		{
       
   122 		aMobilePhone.NotifyALSLineChange(reqStatus,aLSLine);
       
   123 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyALSLineChange);
       
   124 		User::WaitForRequest( reqStatus );
       
   125 		}
       
   126 	while( KErrNone == reqStatus.Int() );
       
   127 	}
       
   128 
       
   129 		
       
   130 /**
       
   131 * Notify cleanup for RMobilePhone::NotifyAlternatingCallCapsChange
       
   132 */	
       
   133 void CEtelSessionMgr::CleanupMobilePhoneNotifyAlternatingCallCapsChange( 
       
   134 					RMobilePhone& aMobilePhone )
       
   135 
       
   136 	{
       
   137 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyAlternatingCallCapsChange"));
       
   138 	TRequestStatus reqStatus;
       
   139 	TUint32 caps;
       
   140 	do 
       
   141 		{
       
   142 		aMobilePhone.NotifyAlternatingCallCapsChange(reqStatus,caps);
       
   143 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyAlternatingCallCapsChange);
       
   144 		User::WaitForRequest( reqStatus );
       
   145 		}
       
   146 	while( KErrNone == reqStatus.Int() );
       
   147 	}
       
   148 
       
   149 		
       
   150 /**
       
   151 * Notify cleanup for RMobilePhone::NotifyAlternatingCallModeChange
       
   152 */	
       
   153 void CEtelSessionMgr::CleanupMobilePhoneNotifyAlternatingCallModeChange( 
       
   154 					RMobilePhone& aMobilePhone )
       
   155 
       
   156 	{
       
   157 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyAlternatingCallModeChange"));
       
   158 	TRequestStatus reqStatus;
       
   159 	RMobilePhone::TMobilePhoneAlternatingCallMode mode;
       
   160 	RMobilePhone::TMobileService firstService;
       
   161 	do 
       
   162 		{
       
   163 		aMobilePhone.NotifyAlternatingCallModeChange(reqStatus,mode,firstService);
       
   164 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyAlternatingCallModeChange);
       
   165 		User::WaitForRequest( reqStatus );
       
   166 		}
       
   167 	while( KErrNone == reqStatus.Int() );
       
   168 	}
       
   169 
       
   170 		
       
   171 /**
       
   172 * Notify cleanup for RMobilePhone::NotifyCCBSRecall
       
   173 */	
       
   174 void CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSRecall( 
       
   175 					RMobilePhone& aMobilePhone )
       
   176 
       
   177 	{
       
   178 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSRecall"));
       
   179 	TRequestStatus reqStatus;
       
   180 	RMobilePhone::TMobilePhoneCCBSEntryV1 pkgType;
       
   181 	RMobilePhone::TMobilePhoneCCBSEntryV1Pckg pkgArg(pkgType);
       
   182 	do 
       
   183 		{
       
   184 		aMobilePhone.NotifyCCBSRecall(reqStatus,pkgArg);
       
   185 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCCBSRecall);
       
   186 		User::WaitForRequest( reqStatus );
       
   187 		}
       
   188 	while( KErrNone == reqStatus.Int() );
       
   189 	}
       
   190 
       
   191 		
       
   192 /**
       
   193 * Notify cleanup for RMobilePhone::NotifyCCBSRecall
       
   194 */	
       
   195 void CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSRecall1( 
       
   196 					RMobilePhone& aMobilePhone )
       
   197 
       
   198 	{
       
   199 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSRecall1"));
       
   200 	TRequestStatus reqStatus;
       
   201 	RMobilePhone::TMobilePhoneCCBSEntryV2 pkgType;
       
   202 	RMobilePhone::TMobilePhoneCCBSEntryV2Pckg pkgArg(pkgType);
       
   203 	do 
       
   204 		{
       
   205 		aMobilePhone.NotifyCCBSRecall(reqStatus,pkgArg);
       
   206 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCCBSRecall);
       
   207 		User::WaitForRequest( reqStatus );
       
   208 		}
       
   209 	while( KErrNone == reqStatus.Int() );
       
   210 	}
       
   211 
       
   212 		
       
   213 /**
       
   214 * Notify cleanup for RMobilePhone::NotifyCCBSStatusChange
       
   215 */	
       
   216 void CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSStatusChange( 
       
   217 					RMobilePhone& aMobilePhone )
       
   218 
       
   219 	{
       
   220 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCCBSStatusChange"));
       
   221 	TRequestStatus reqStatus;
       
   222 	RMobilePhone::TMobilePhoneCCBSStatus ccbsStatus;
       
   223 	do 
       
   224 		{
       
   225 		aMobilePhone.NotifyCCBSStatusChange(reqStatus,ccbsStatus);
       
   226 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCCBSStatusChange);
       
   227 		User::WaitForRequest( reqStatus );
       
   228 		}
       
   229 	while( KErrNone == reqStatus.Int() );
       
   230 	}
       
   231 
       
   232 		
       
   233 /**
       
   234 * Notify cleanup for RMobilePhone::NotifyCallBarringStatusChange
       
   235 */	
       
   236 void CEtelSessionMgr::CleanupMobilePhoneNotifyCallBarringStatusChange( 
       
   237 					RMobilePhone& aMobilePhone )
       
   238 
       
   239 	{
       
   240 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCallBarringStatusChange"));
       
   241 	TRequestStatus reqStatus;
       
   242 	RMobilePhone::TMobilePhoneCBCondition condition;
       
   243 	do 
       
   244 		{
       
   245 		aMobilePhone.NotifyCallBarringStatusChange(reqStatus,condition);
       
   246 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCallBarringStatusChange);
       
   247 		User::WaitForRequest( reqStatus );
       
   248 		}
       
   249 	while( KErrNone == reqStatus.Int() );
       
   250 	}
       
   251 
       
   252 		
       
   253 /**
       
   254 * Notify cleanup for RMobilePhone::NotifyCallForwardingActive
       
   255 */	
       
   256 void CEtelSessionMgr::CleanupMobilePhoneNotifyCallForwardingActive( 
       
   257 					RMobilePhone& aMobilePhone )
       
   258 
       
   259 	{
       
   260 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCallForwardingActive"));
       
   261 	TRequestStatus reqStatus;
       
   262 	RMobilePhone::TMobileService serviceGroup;
       
   263 	RMobilePhone::TMobilePhoneCFActive activeType;
       
   264 	do 
       
   265 		{
       
   266 		aMobilePhone.NotifyCallForwardingActive(reqStatus,serviceGroup,activeType);
       
   267 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCallForwardingActive);
       
   268 		User::WaitForRequest( reqStatus );
       
   269 		}
       
   270 	while( KErrNone == reqStatus.Int() );
       
   271 	}
       
   272 
       
   273 		
       
   274 /**
       
   275 * Notify cleanup for RMobilePhone::NotifyCallForwardingStatusChange
       
   276 */	
       
   277 void CEtelSessionMgr::CleanupMobilePhoneNotifyCallForwardingStatusChange( 
       
   278 					RMobilePhone& aMobilePhone )
       
   279 
       
   280 	{
       
   281 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCallForwardingStatusChange"));
       
   282 	TRequestStatus reqStatus;
       
   283 	RMobilePhone::TMobilePhoneCFCondition condition;
       
   284 	do 
       
   285 		{
       
   286 		aMobilePhone.NotifyCallForwardingStatusChange(reqStatus,condition);
       
   287 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCallForwardingStatusChange);
       
   288 		User::WaitForRequest( reqStatus );
       
   289 		}
       
   290 	while( KErrNone == reqStatus.Int() );
       
   291 	}
       
   292 
       
   293 		
       
   294 /**
       
   295 * Notify cleanup for RMobilePhone::NotifyCallServiceCapsChange
       
   296 */	
       
   297 void CEtelSessionMgr::CleanupMobilePhoneNotifyCallServiceCapsChange( 
       
   298 					RMobilePhone& aMobilePhone )
       
   299 
       
   300 	{
       
   301 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCallServiceCapsChange"));
       
   302 	TRequestStatus reqStatus;
       
   303 	TUint32 caps;
       
   304 	do 
       
   305 		{
       
   306 		aMobilePhone.NotifyCallServiceCapsChange(reqStatus,caps);
       
   307 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCallServiceCapsChange);
       
   308 		User::WaitForRequest( reqStatus );
       
   309 		}
       
   310 	while( KErrNone == reqStatus.Int() );
       
   311 	}
       
   312 
       
   313 		
       
   314 /**
       
   315 * Notify cleanup for RMobilePhone::NotifyCallWaitingStatusChange
       
   316 */	
       
   317 void CEtelSessionMgr::CleanupMobilePhoneNotifyCallWaitingStatusChange( 
       
   318 					RMobilePhone& aMobilePhone )
       
   319 
       
   320 	{
       
   321 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCallWaitingStatusChange"));
       
   322 	TRequestStatus reqStatus;
       
   323 	RMobilePhone::TMobilePhoneCWInfoEntryV1 pkgType;
       
   324 	RMobilePhone::TMobilePhoneCWInfoEntryV1Pckg pkgArg(pkgType);
       
   325 	do 
       
   326 		{
       
   327 		aMobilePhone.NotifyCallWaitingStatusChange(reqStatus,pkgArg);
       
   328 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCallWaitingStatusChange);
       
   329 		User::WaitForRequest( reqStatus );
       
   330 		}
       
   331 	while( KErrNone == reqStatus.Int() );
       
   332 	}
       
   333 
       
   334 		
       
   335 /**
       
   336 * Notify cleanup for RMobilePhone::NotifyCipheringIndicatorStatus
       
   337 */	
       
   338 void CEtelSessionMgr::CleanupMobilePhoneNotifyCipheringIndicatorStatus( 
       
   339 					RMobilePhone& aMobilePhone )
       
   340 
       
   341 	{
       
   342 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCipheringIndicatorStatus"));
       
   343 	TRequestStatus reqStatus;
       
   344 	RMobilePhone::TMobileCallCipheringIndicator indicatorStatus;
       
   345 	do 
       
   346 		{
       
   347 		aMobilePhone.NotifyCipheringIndicatorStatus(reqStatus,indicatorStatus);
       
   348 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCipheringIndicatorStatus);
       
   349 		User::WaitForRequest( reqStatus );
       
   350 		}
       
   351 	while( KErrNone == reqStatus.Int() );
       
   352 	}
       
   353 
       
   354 		
       
   355 /**
       
   356 * Notify cleanup for RMobilePhone::NotifyCostCapsChange
       
   357 */	
       
   358 void CEtelSessionMgr::CleanupMobilePhoneNotifyCostCapsChange( 
       
   359 					RMobilePhone& aMobilePhone )
       
   360 
       
   361 	{
       
   362 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCostCapsChange"));
       
   363 	TRequestStatus reqStatus;
       
   364 	TUint32 caps;
       
   365 	do 
       
   366 		{
       
   367 		aMobilePhone.NotifyCostCapsChange(reqStatus,caps);
       
   368 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCostCapsChange);
       
   369 		User::WaitForRequest( reqStatus );
       
   370 		}
       
   371 	while( KErrNone == reqStatus.Int() );
       
   372 	}
       
   373 
       
   374 		
       
   375 /**
       
   376 * Notify cleanup for RMobilePhone::NotifyDTMFCapsChange
       
   377 */	
       
   378 void CEtelSessionMgr::CleanupMobilePhoneNotifyDTMFCapsChange( 
       
   379 					RMobilePhone& aMobilePhone )
       
   380 
       
   381 	{
       
   382 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyDTMFCapsChange"));
       
   383 	TRequestStatus reqStatus;
       
   384 	TUint32 caps;
       
   385 	do 
       
   386 		{
       
   387 		aMobilePhone.NotifyDTMFCapsChange(reqStatus,caps);
       
   388 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyDTMFCapsChange);
       
   389 		User::WaitForRequest( reqStatus );
       
   390 		}
       
   391 	while( KErrNone == reqStatus.Int() );
       
   392 	}
       
   393 
       
   394 		
       
   395 /**
       
   396 * Notify cleanup for RMobilePhone::NotifyDTMFEvent
       
   397 */	
       
   398 void CEtelSessionMgr::CleanupMobilePhoneNotifyDTMFEvent( 
       
   399 					RMobilePhone& aMobilePhone )
       
   400 
       
   401 	{
       
   402 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyDTMFEvent"));
       
   403 	TRequestStatus reqStatus;
       
   404 	RMobilePhone::TMobilePhoneDTMFEvent event;
       
   405 	do 
       
   406 		{
       
   407 		aMobilePhone.NotifyDTMFEvent(reqStatus,event);
       
   408 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyDTMFEvent);
       
   409 		User::WaitForRequest( reqStatus );
       
   410 		}
       
   411 	while( KErrNone == reqStatus.Int() );
       
   412 	}
       
   413 
       
   414 		
       
   415 /**
       
   416 * Notify cleanup for RMobilePhone::NotifyFdnStatusChange
       
   417 */	
       
   418 void CEtelSessionMgr::CleanupMobilePhoneNotifyFdnStatusChange( 
       
   419 					RMobilePhone& aMobilePhone )
       
   420 
       
   421 	{
       
   422 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyFdnStatusChange"));
       
   423 	TRequestStatus reqStatus;
       
   424 	RMobilePhone::TMobilePhoneFdnStatus fdnStatus;
       
   425 	do 
       
   426 		{
       
   427 		aMobilePhone.NotifyFdnStatusChange(reqStatus,fdnStatus);
       
   428 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyFdnStatusChange);
       
   429 		User::WaitForRequest( reqStatus );
       
   430 		}
       
   431 	while( KErrNone == reqStatus.Int() );
       
   432 	}
       
   433 
       
   434 		
       
   435 /**
       
   436 * Notify cleanup for RMobilePhone::NotifyIccAccessCapsChange
       
   437 */	
       
   438 void CEtelSessionMgr::CleanupMobilePhoneNotifyIccAccessCapsChange( 
       
   439 					RMobilePhone& aMobilePhone )
       
   440 
       
   441 	{
       
   442 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIccAccessCapsChange"));
       
   443 	TRequestStatus reqStatus;
       
   444 	TUint32 caps;
       
   445 	do 
       
   446 		{
       
   447 		aMobilePhone.NotifyIccAccessCapsChange(reqStatus,caps);
       
   448 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIccAccessCapsChange);
       
   449 		User::WaitForRequest( reqStatus );
       
   450 		}
       
   451 	while( KErrNone == reqStatus.Int() );
       
   452 	}
       
   453 
       
   454 		
       
   455 /**
       
   456 * Notify cleanup for RMobilePhone::NotifyIdentityServiceStatus
       
   457 */	
       
   458 void CEtelSessionMgr::CleanupMobilePhoneNotifyIdentityServiceStatus( 
       
   459 					RMobilePhone& aMobilePhone )
       
   460 
       
   461 	{
       
   462 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIdentityServiceStatus"));
       
   463 	TRequestStatus reqStatus;
       
   464 	RMobilePhone::TMobilePhoneIdService service = RMobilePhone::EIdServiceUnspecified;
       
   465 	RMobilePhone::TMobilePhoneIdServiceStatus status;
       
   466 	do 
       
   467 		{
       
   468 		aMobilePhone.NotifyIdentityServiceStatus(reqStatus,service,status);
       
   469 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIdentityServiceStatus);
       
   470 		User::WaitForRequest( reqStatus );
       
   471 		}
       
   472 	while( KErrNone == reqStatus.Int() );
       
   473 	}
       
   474 
       
   475 		
       
   476 /**
       
   477 * Notify cleanup for RMobilePhone::NotifyIdentitySuppressionRejected
       
   478 */	
       
   479 void CEtelSessionMgr::CleanupMobilePhoneNotifyIdentitySuppressionRejected( 
       
   480 					RMobilePhone& aMobilePhone )
       
   481 
       
   482 	{
       
   483 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIdentitySuppressionRejected"));
       
   484 	TRequestStatus reqStatus;
       
   485 	do 
       
   486 		{
       
   487 		aMobilePhone.NotifyIdentitySuppressionRejected(reqStatus);
       
   488 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIdentitySuppressionRejected);
       
   489 		User::WaitForRequest( reqStatus );
       
   490 		}
       
   491 	while( KErrNone == reqStatus.Int() );
       
   492 	}
       
   493 
       
   494 		
       
   495 /**
       
   496 * Notify cleanup for RMobilePhone::NotifyIncomingCallTypeChange
       
   497 */	
       
   498 void CEtelSessionMgr::CleanupMobilePhoneNotifyIncomingCallTypeChange( 
       
   499 					RMobilePhone& aMobilePhone )
       
   500 
       
   501 	{
       
   502 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIncomingCallTypeChange"));
       
   503 	TRequestStatus reqStatus;
       
   504 	RMobilePhone::TMobilePhoneIncomingCallType callType;
       
   505 	RMobileCall::TMobileDataCallParamsV1 pkgType;
       
   506 	RMobileCall::TMobileDataCallParamsV1Pckg pkgArg(pkgType);
       
   507 	do 
       
   508 		{
       
   509 		aMobilePhone.NotifyIncomingCallTypeChange(reqStatus,callType,pkgArg);
       
   510 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIncomingCallTypeChange);
       
   511 		User::WaitForRequest( reqStatus );
       
   512 		}
       
   513 	while( KErrNone == reqStatus.Int() );
       
   514 	}
       
   515 
       
   516 		
       
   517 /**
       
   518 * Notify cleanup for RMobilePhone::NotifyIndicatorChange
       
   519 */	
       
   520 void CEtelSessionMgr::CleanupMobilePhoneNotifyIndicatorChange( 
       
   521 					RMobilePhone& aMobilePhone )
       
   522 
       
   523 	{
       
   524 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIndicatorChange"));
       
   525 	TRequestStatus reqStatus;
       
   526 	TUint32 indicator;
       
   527 	do 
       
   528 		{
       
   529 		aMobilePhone.NotifyIndicatorChange(reqStatus,indicator);
       
   530 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIndicatorChange);
       
   531 		User::WaitForRequest( reqStatus );
       
   532 		}
       
   533 	while( KErrNone == reqStatus.Int() );
       
   534 	}
       
   535 
       
   536 		
       
   537 /**
       
   538 * Notify cleanup for RMobilePhone::NotifyMessageWaiting
       
   539 */	
       
   540 void CEtelSessionMgr::CleanupMobilePhoneNotifyMessageWaiting( 
       
   541 					RMobilePhone& aMobilePhone )
       
   542 
       
   543 	{
       
   544 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMessageWaiting"));
       
   545 	TRequestStatus reqStatus;
       
   546 	TInt count;
       
   547 	do 
       
   548 		{
       
   549 		aMobilePhone.NotifyMessageWaiting(reqStatus,count);
       
   550 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMessageWaiting);
       
   551 		User::WaitForRequest( reqStatus );
       
   552 		}
       
   553 	while( KErrNone == reqStatus.Int() );
       
   554 	}
       
   555 
       
   556 		
       
   557 /**
       
   558 * Notify cleanup for RMobilePhone::NotifyModeChange
       
   559 */	
       
   560 void CEtelSessionMgr::CleanupMobilePhoneNotifyModeChange( 
       
   561 					RMobilePhone& aMobilePhone )
       
   562 
       
   563 	{
       
   564 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyModeChange"));
       
   565 	TRequestStatus reqStatus;
       
   566 	RMobilePhone::TMobilePhoneNetworkMode networkMode;
       
   567 	do 
       
   568 		{
       
   569 		aMobilePhone.NotifyModeChange(reqStatus,networkMode);
       
   570 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyModeChange);
       
   571 		User::WaitForRequest( reqStatus );
       
   572 		}
       
   573 	while( KErrNone == reqStatus.Int() );
       
   574 	}
       
   575 
       
   576 		
       
   577 /**
       
   578 * Notify cleanup for RMobilePhone::NotifyMulticallIndicatorChange
       
   579 */	
       
   580 void CEtelSessionMgr::CleanupMobilePhoneNotifyMulticallIndicatorChange( 
       
   581 					RMobilePhone& aMobilePhone )
       
   582 
       
   583 	{
       
   584 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMulticallIndicatorChange"));
       
   585 	TRequestStatus reqStatus;
       
   586 	RMobilePhone::TMobilePhoneMulticallIndicator multicallIndicator;
       
   587 	do 
       
   588 		{
       
   589 		aMobilePhone.NotifyMulticallIndicatorChange(reqStatus,multicallIndicator);
       
   590 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMulticallIndicatorChange);
       
   591 		User::WaitForRequest( reqStatus );
       
   592 		}
       
   593 	while( KErrNone == reqStatus.Int() );
       
   594 	}
       
   595 
       
   596 		
       
   597 /**
       
   598 * Notify cleanup for RMobilePhone::NotifyMulticallParamsChange
       
   599 */	
       
   600 void CEtelSessionMgr::CleanupMobilePhoneNotifyMulticallParamsChange( 
       
   601 					RMobilePhone& aMobilePhone )
       
   602 
       
   603 	{
       
   604 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMulticallParamsChange"));
       
   605 	TRequestStatus reqStatus;
       
   606 	RMobilePhone::TMobilePhoneMulticallSettingsV1 pkgType;
       
   607 	RMobilePhone::TMobilePhoneMulticallSettingsV1Pckg pkgArg(pkgType);
       
   608 	do 
       
   609 		{
       
   610 		aMobilePhone.NotifyMulticallParamsChange(reqStatus,pkgArg);
       
   611 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMulticallParamsChange);
       
   612 		User::WaitForRequest( reqStatus );
       
   613 		}
       
   614 	while( KErrNone == reqStatus.Int() );
       
   615 	}
       
   616 
       
   617 		
       
   618 /**
       
   619 * Notify cleanup for RMobilePhone::NotifyMultimediaCallPreferenceChange
       
   620 */	
       
   621 void CEtelSessionMgr::CleanupMobilePhoneNotifyMultimediaCallPreferenceChange( 
       
   622 					RMobilePhone& aMobilePhone )
       
   623 
       
   624 	{
       
   625 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMultimediaCallPreferenceChange"));
       
   626 	TRequestStatus reqStatus;
       
   627 	RMobilePhone::TMobilePhoneMultimediaSettings mmSettings;
       
   628 	do 
       
   629 		{
       
   630 		aMobilePhone.NotifyMultimediaCallPreferenceChange(reqStatus,mmSettings);
       
   631 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMultimediaCallPreferenceChange);
       
   632 		User::WaitForRequest( reqStatus );
       
   633 		}
       
   634 	while( KErrNone == reqStatus.Int() );
       
   635 	}
       
   636 
       
   637 		
       
   638 /**
       
   639 * Notify cleanup for RMobilePhone::NotifyNetworkInvScanChange
       
   640 */	
       
   641 void CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkInvScanChange( 
       
   642 					RMobilePhone& aMobilePhone )
       
   643 
       
   644 	{
       
   645 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkInvScanChange"));
       
   646 	TRequestStatus reqStatus;
       
   647 	RMobilePhone::TMobilePhoneInvestigationScan setting;
       
   648 	do 
       
   649 		{
       
   650 		aMobilePhone.NotifyNetworkInvScanChange(reqStatus,setting);
       
   651 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNetworkInvScanChange);
       
   652 		User::WaitForRequest( reqStatus );
       
   653 		}
       
   654 	while( KErrNone == reqStatus.Int() );
       
   655 	}
       
   656 
       
   657 		
       
   658 /**
       
   659 * Notify cleanup for RMobilePhone::NotifyNetworkInvScanEvent
       
   660 */	
       
   661 void CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkInvScanEvent( 
       
   662 					RMobilePhone& aMobilePhone )
       
   663 
       
   664 	{
       
   665 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkInvScanEvent"));
       
   666 	TRequestStatus reqStatus;
       
   667 	RMobilePhone::TMobilePhoneInvestigationScanEvent event;
       
   668 	do 
       
   669 		{
       
   670 		aMobilePhone.NotifyNetworkInvScanEvent(reqStatus,event);
       
   671 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNetworkInvScanEvent);
       
   672 		User::WaitForRequest( reqStatus );
       
   673 		}
       
   674 	while( KErrNone == reqStatus.Int() );
       
   675 	}
       
   676 
       
   677 		
       
   678 /**
       
   679 * Notify cleanup for RMobilePhone::NotifyNetworkRegistrationStatusChange
       
   680 */	
       
   681 void CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkRegistrationStatusChange( 
       
   682 					RMobilePhone& aMobilePhone )
       
   683 
       
   684 	{
       
   685 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkRegistrationStatusChange"));
       
   686 	TRequestStatus reqStatus;
       
   687 	RMobilePhone::TMobilePhoneRegistrationStatus status;
       
   688 	do 
       
   689 		{
       
   690 		aMobilePhone.NotifyNetworkRegistrationStatusChange(reqStatus,status);
       
   691 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNetworkRegistrationStatusChange);
       
   692 		User::WaitForRequest( reqStatus );
       
   693 		}
       
   694 	while( KErrNone == reqStatus.Int() );
       
   695 	}
       
   696 
       
   697 		
       
   698 /**
       
   699 * Notify cleanup for RMobilePhone::NotifyNetworkSecurityLevelChange
       
   700 */	
       
   701 void CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkSecurityLevelChange( 
       
   702 					RMobilePhone& aMobilePhone )
       
   703 
       
   704 	{
       
   705 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkSecurityLevelChange"));
       
   706 	TRequestStatus reqStatus;
       
   707 	RMobilePhone::TMobilePhoneNetworkSecurity security;
       
   708 	do 
       
   709 		{
       
   710 		aMobilePhone.NotifyNetworkSecurityLevelChange(reqStatus,security);
       
   711 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNetworkSecurityLevelChange);
       
   712 		User::WaitForRequest( reqStatus );
       
   713 		}
       
   714 	while( KErrNone == reqStatus.Int() );
       
   715 	}
       
   716 
       
   717 		
       
   718 /**
       
   719 * Notify cleanup for RMobilePhone::NotifySecurityCapsChange
       
   720 */	
       
   721 void CEtelSessionMgr::CleanupMobilePhoneNotifySecurityCapsChange( 
       
   722 					RMobilePhone& aMobilePhone )
       
   723 
       
   724 	{
       
   725 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySecurityCapsChange"));
       
   726 	TRequestStatus reqStatus;
       
   727 	TUint32 caps;
       
   728 	do 
       
   729 		{
       
   730 		aMobilePhone.NotifySecurityCapsChange(reqStatus,caps);
       
   731 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySecurityCapsChange);
       
   732 		User::WaitForRequest( reqStatus );
       
   733 		}
       
   734 	while( KErrNone == reqStatus.Int() );
       
   735 	}
       
   736 
       
   737 		
       
   738 /**
       
   739 * Notify cleanup for RMobilePhone::NotifySecurityEvent
       
   740 */	
       
   741 void CEtelSessionMgr::CleanupMobilePhoneNotifySecurityEvent( 
       
   742 					RMobilePhone& aMobilePhone )
       
   743 
       
   744 	{
       
   745 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySecurityEvent"));
       
   746 	TRequestStatus reqStatus;
       
   747 	RMobilePhone::TMobilePhoneSecurityEvent event;
       
   748 	do 
       
   749 		{
       
   750 		aMobilePhone.NotifySecurityEvent(reqStatus,event);
       
   751 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySecurityEvent);
       
   752 		User::WaitForRequest( reqStatus );
       
   753 		}
       
   754 	while( KErrNone == reqStatus.Int() );
       
   755 	}
       
   756 
       
   757 		
       
   758 /**
       
   759 * Notify cleanup for RMobilePhone::NotifySendNetworkServiceRequest
       
   760 */	
       
   761 void CEtelSessionMgr::CleanupMobilePhoneNotifySendNetworkServiceRequest( 
       
   762 					RMobilePhone& aMobilePhone )
       
   763 
       
   764 	{
       
   765 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySendNetworkServiceRequest"));
       
   766 	TRequestStatus reqStatus;
       
   767 	RMobilePhone::TMobilePhoneNotifySendSSOperation operation = RMobilePhone::ESendSSInvoke;
       
   768 	RMobilePhone::TMobilePhoneSendSSRequestV3 pkgType;
       
   769 	RMobilePhone::TMobilePhoneSendSSRequestV3Pckg pkgArg(pkgType);
       
   770 	do 
       
   771 		{
       
   772 		aMobilePhone.NotifySendNetworkServiceRequest(reqStatus,operation,pkgArg);
       
   773 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySendNetworkServiceRequest);
       
   774 		User::WaitForRequest( reqStatus );
       
   775 		}
       
   776 	while( KErrNone == reqStatus.Int() );
       
   777 	}
       
   778 
       
   779 		
       
   780 /**
       
   781 * Notify cleanup for RMobilePhone::NotifySignalStrengthChange
       
   782 */	
       
   783 void CEtelSessionMgr::CleanupMobilePhoneNotifySignalStrengthChange( 
       
   784 					RMobilePhone& aMobilePhone )
       
   785 
       
   786 	{
       
   787 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySignalStrengthChange"));
       
   788 	TRequestStatus reqStatus;
       
   789 	TInt32 signalStrength;
       
   790 	TInt8 bar;
       
   791 	do 
       
   792 		{
       
   793 		aMobilePhone.NotifySignalStrengthChange(reqStatus,signalStrength,bar);
       
   794 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySignalStrengthChange);
       
   795 		User::WaitForRequest( reqStatus );
       
   796 		}
       
   797 	while( KErrNone == reqStatus.Int() );
       
   798 	}
       
   799 
       
   800 		
       
   801 /**
       
   802 * Notify cleanup for RMobilePhone::NotifyPreferredNetworksListChange
       
   803 */	
       
   804 void CEtelSessionMgr::CleanupMobilePhoneNotifyPreferredNetworksListChange( 
       
   805 					RMobilePhone& aMobilePhone )
       
   806 
       
   807 	{
       
   808 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyPreferredNetworksListChange"));
       
   809 	TRequestStatus reqStatus;
       
   810 	do 
       
   811 		{
       
   812 		aMobilePhone.NotifyPreferredNetworksListChange(reqStatus);
       
   813 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyStorePreferredNetworksListChange);
       
   814 		User::WaitForRequest( reqStatus );
       
   815 		}
       
   816 	while( KErrNone == reqStatus.Int() );
       
   817 	}
       
   818 
       
   819 		
       
   820 /**
       
   821 * Notify cleanup for RMobilePhone::NotifyStopInDTMFString
       
   822 */	
       
   823 void CEtelSessionMgr::CleanupMobilePhoneNotifyStopInDTMFString( 
       
   824 					RMobilePhone& aMobilePhone )
       
   825 
       
   826 	{
       
   827 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyStopInDTMFString"));
       
   828 	TRequestStatus reqStatus;
       
   829 	do 
       
   830 		{
       
   831 		aMobilePhone.NotifyStopInDTMFString(reqStatus);
       
   832 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyStopInDTMFString);
       
   833 		User::WaitForRequest( reqStatus );
       
   834 		}
       
   835 	while( KErrNone == reqStatus.Int() );
       
   836 	}
       
   837 
       
   838 		
       
   839 /**
       
   840 * Notify cleanup for RMobilePhone::NotifyAirTimeDurationChange
       
   841 */	
       
   842 void CEtelSessionMgr::CleanupMobilePhoneNotifyAirTimeDurationChange( 
       
   843 					RMobilePhone& aMobilePhone )
       
   844 
       
   845 	{
       
   846 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyAirTimeDurationChange"));
       
   847 	TRequestStatus reqStatus;
       
   848 	TTimeIntervalSeconds time;
       
   849 	do 
       
   850 		{
       
   851 		aMobilePhone.NotifyAirTimeDurationChange(reqStatus,time);
       
   852 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyAirTimeDurationChange);
       
   853 		User::WaitForRequest( reqStatus );
       
   854 		}
       
   855 	while( KErrNone == reqStatus.Int() );
       
   856 	}
       
   857 
       
   858 		
       
   859 /**
       
   860 * Notify cleanup for RMobilePhone::NotifyCostInfoChange
       
   861 */	
       
   862 void CEtelSessionMgr::CleanupMobilePhoneNotifyCostInfoChange( 
       
   863 					RMobilePhone& aMobilePhone )
       
   864 
       
   865 	{
       
   866 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCostInfoChange"));
       
   867 	TRequestStatus reqStatus;
       
   868 	RMobilePhone::TMobilePhoneCostInfoV1 pkgType;
       
   869 	RMobilePhone::TMobilePhoneCostInfoV1Pckg pkgArg(pkgType);
       
   870 	do 
       
   871 		{
       
   872 		aMobilePhone.NotifyCostInfoChange(reqStatus,pkgArg);
       
   873 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCostInfoChange);
       
   874 		User::WaitForRequest( reqStatus );
       
   875 		}
       
   876 	while( KErrNone == reqStatus.Int() );
       
   877 	}
       
   878 
       
   879 		
       
   880 /**
       
   881 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   882 */	
       
   883 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange( 
       
   884 					RMobilePhone& aMobilePhone )
       
   885 
       
   886 	{
       
   887 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange"));
       
   888 	TRequestStatus reqStatus;
       
   889 	RMobilePhone::TMobilePhoneNetworkInfoV1 pkgType;
       
   890 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg pkgArg(pkgType);
       
   891 	do 
       
   892 		{
       
   893 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg);
       
   894 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkNoLocationChange);
       
   895 		User::WaitForRequest( reqStatus );
       
   896 		}
       
   897 	while( KErrNone == reqStatus.Int() );
       
   898 	}
       
   899 
       
   900 		
       
   901 /**
       
   902 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   903 */	
       
   904 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange1( 
       
   905 					RMobilePhone& aMobilePhone )
       
   906 
       
   907 	{
       
   908 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange1"));
       
   909 	TRequestStatus reqStatus;
       
   910 	RMobilePhone::TMobilePhoneNetworkInfoV2 pkgType;
       
   911 	RMobilePhone::TMobilePhoneNetworkInfoV2Pckg pkgArg(pkgType);
       
   912 	do 
       
   913 		{
       
   914 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg);
       
   915 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkNoLocationChange);
       
   916 		User::WaitForRequest( reqStatus );
       
   917 		}
       
   918 	while( KErrNone == reqStatus.Int() );
       
   919 	}
       
   920 
       
   921 		
       
   922 /**
       
   923 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   924 */	
       
   925 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange2( 
       
   926 					RMobilePhone& aMobilePhone )
       
   927 
       
   928 	{
       
   929 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange2"));
       
   930 	TRequestStatus reqStatus;
       
   931 	RMobilePhone::TMobilePhoneNetworkInfoV5 pkgType;
       
   932 	RMobilePhone::TMobilePhoneNetworkInfoV5Pckg pkgArg(pkgType);
       
   933 	do 
       
   934 		{
       
   935 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg);
       
   936 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkNoLocationChange);
       
   937 		User::WaitForRequest( reqStatus );
       
   938 		}
       
   939 	while( KErrNone == reqStatus.Int() );
       
   940 	}
       
   941 
       
   942 		
       
   943 /**
       
   944 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   945 */	
       
   946 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange3( 
       
   947 					RMobilePhone& aMobilePhone )
       
   948 
       
   949 	{
       
   950 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange3"));
       
   951 	TRequestStatus reqStatus;
       
   952 	RMobilePhone::TMobilePhoneNetworkInfoV1 pkgType;
       
   953 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg pkgArg(pkgType);
       
   954 	RMobilePhone::TMobilePhoneLocationAreaV1 area;
       
   955 	do 
       
   956 		{
       
   957 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg,area);
       
   958 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkChange);
       
   959 		User::WaitForRequest( reqStatus );
       
   960 		}
       
   961 	while( KErrNone == reqStatus.Int() );
       
   962 	}
       
   963 
       
   964 		
       
   965 /**
       
   966 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   967 */	
       
   968 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange4( 
       
   969 					RMobilePhone& aMobilePhone )
       
   970 
       
   971 	{
       
   972 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange4"));
       
   973 	TRequestStatus reqStatus;
       
   974 	RMobilePhone::TMobilePhoneNetworkInfoV2 pkgType;
       
   975 	RMobilePhone::TMobilePhoneNetworkInfoV2Pckg pkgArg(pkgType);
       
   976 	RMobilePhone::TMobilePhoneLocationAreaV1 area;
       
   977 	do 
       
   978 		{
       
   979 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg,area);
       
   980 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkChange);
       
   981 		User::WaitForRequest( reqStatus );
       
   982 		}
       
   983 	while( KErrNone == reqStatus.Int() );
       
   984 	}
       
   985 
       
   986 		
       
   987 /**
       
   988 * Notify cleanup for RMobilePhone::NotifyCurrentNetworkChange
       
   989 */	
       
   990 void CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange5( 
       
   991 					RMobilePhone& aMobilePhone )
       
   992 
       
   993 	{
       
   994 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyCurrentNetworkChange5"));
       
   995 	TRequestStatus reqStatus;
       
   996 	RMobilePhone::TMobilePhoneNetworkInfoV5 pkgType;
       
   997 	RMobilePhone::TMobilePhoneNetworkInfoV5Pckg pkgArg(pkgType);
       
   998 	RMobilePhone::TMobilePhoneLocationAreaV1 area;
       
   999 	do 
       
  1000 		{
       
  1001 		aMobilePhone.NotifyCurrentNetworkChange(reqStatus,pkgArg,area);
       
  1002 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyCurrentNetworkChange);
       
  1003 		User::WaitForRequest( reqStatus );
       
  1004 		}
       
  1005 	while( KErrNone == reqStatus.Int() );
       
  1006 	}
       
  1007 
       
  1008 		
       
  1009 /**
       
  1010 * Notify cleanup for RMobilePhone::NotifyLockInfoChange
       
  1011 */	
       
  1012 void CEtelSessionMgr::CleanupMobilePhoneNotifyLockInfoChange( 
       
  1013 					RMobilePhone& aMobilePhone )
       
  1014 
       
  1015 	{
       
  1016 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyLockInfoChange"));
       
  1017 	TRequestStatus reqStatus;
       
  1018 	RMobilePhone::TMobilePhoneLock lock;
       
  1019 	RMobilePhone::TMobilePhoneLockInfoV1 pkgType;
       
  1020 	RMobilePhone::TMobilePhoneLockInfoV1Pckg pkgArg(pkgType);
       
  1021 	do 
       
  1022 		{
       
  1023 		aMobilePhone.NotifyLockInfoChange(reqStatus,lock,pkgArg);
       
  1024 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyLockInfoChange);
       
  1025 		User::WaitForRequest( reqStatus );
       
  1026 		}
       
  1027 	while( KErrNone == reqStatus.Int() );
       
  1028 	}
       
  1029 
       
  1030 		
       
  1031 /**
       
  1032 * Notify cleanup for RMobilePhone::NotifyNITZInfoChange
       
  1033 */	
       
  1034 void CEtelSessionMgr::CleanupMobilePhoneNotifyNITZInfoChange( 
       
  1035 					RMobilePhone& aMobilePhone )
       
  1036 
       
  1037 	{
       
  1038 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNITZInfoChange"));
       
  1039 	TRequestStatus reqStatus;
       
  1040 	RMobilePhone::TMobilePhoneNITZ nITZInfo;
       
  1041 	do 
       
  1042 		{
       
  1043 		aMobilePhone.NotifyNITZInfoChange(reqStatus,nITZInfo);
       
  1044 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNITZInfoChange);
       
  1045 		User::WaitForRequest( reqStatus );
       
  1046 		}
       
  1047 	while( KErrNone == reqStatus.Int() );
       
  1048 	}
       
  1049 
       
  1050 		
       
  1051 /**
       
  1052 * Notify cleanup for RMobilePhone::NotifyNetworkSelectionSettingChange
       
  1053 */	
       
  1054 void CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkSelectionSettingChange( 
       
  1055 					RMobilePhone& aMobilePhone )
       
  1056 
       
  1057 	{
       
  1058 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyNetworkSelectionSettingChange"));
       
  1059 	TRequestStatus reqStatus;
       
  1060 	RMobilePhone::TMobilePhoneNetworkSelectionV1 pkgType;
       
  1061 	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg pkgArg(pkgType);
       
  1062 	do 
       
  1063 		{
       
  1064 		aMobilePhone.NotifyNetworkSelectionSettingChange(reqStatus,pkgArg);
       
  1065 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyNetworkSelectionSettingChange);
       
  1066 		User::WaitForRequest( reqStatus );
       
  1067 		}
       
  1068 	while( KErrNone == reqStatus.Int() );
       
  1069 	}
       
  1070 
       
  1071 		
       
  1072 /**
       
  1073 * Notify cleanup for RMobilePhone::NotifySecurityCodeInfoChange
       
  1074 */	
       
  1075 void CEtelSessionMgr::CleanupMobilePhoneNotifySecurityCodeInfoChange( 
       
  1076 					RMobilePhone& aMobilePhone )
       
  1077 
       
  1078 	{
       
  1079 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySecurityCodeInfoChange"));
       
  1080 	TRequestStatus reqStatus;
       
  1081 	RMobilePhone::TMobilePhoneSecurityCode securityCode;
       
  1082 	RMobilePhone::TMobilePhoneSecurityCodeInfoV5 pkgType;
       
  1083 	RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg pkgArg(pkgType);
       
  1084 	do 
       
  1085 		{
       
  1086 		aMobilePhone.NotifySecurityCodeInfoChange(reqStatus,securityCode,pkgArg);
       
  1087 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySecurityCodeInfoChange);
       
  1088 		User::WaitForRequest( reqStatus );
       
  1089 		}
       
  1090 	while( KErrNone == reqStatus.Int() );
       
  1091 	}
       
  1092 
       
  1093 		
       
  1094 /**
       
  1095 * Notify cleanup for RMobilePhone::NotifyUSimApplicationsInfoChange
       
  1096 */	
       
  1097 void CEtelSessionMgr::CleanupMobilePhoneNotifyUSimApplicationsInfoChange( 
       
  1098 					RMobilePhone& aMobilePhone )
       
  1099 
       
  1100 	{
       
  1101 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyUSimApplicationsInfoChange"));
       
  1102 	TRequestStatus reqStatus;
       
  1103 	TInt count;
       
  1104 	RMobilePhone::TAID activeAID;
       
  1105 	do 
       
  1106 		{
       
  1107 		aMobilePhone.NotifyUSimApplicationsInfoChange(reqStatus,count,activeAID);
       
  1108 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyUSimApplicationsInfoChange);
       
  1109 		User::WaitForRequest( reqStatus );
       
  1110 		}
       
  1111 	while( KErrNone == reqStatus.Int() );
       
  1112 	}
       
  1113 
       
  1114 		
       
  1115 /**
       
  1116 * Notify cleanup for RMobilePhone::NotifyUSimAppsSelectionModeChange
       
  1117 */	
       
  1118 void CEtelSessionMgr::CleanupMobilePhoneNotifyUSimAppsSelectionModeChange( 
       
  1119 					RMobilePhone& aMobilePhone )
       
  1120 
       
  1121 	{
       
  1122 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyUSimAppsSelectionModeChange"));
       
  1123 	TRequestStatus reqStatus;
       
  1124 	RMobilePhone::TUSimSelectionMode uSimSelectionMode;
       
  1125 	do 
       
  1126 		{
       
  1127 		aMobilePhone.NotifyUSimAppsSelectionModeChange(reqStatus,uSimSelectionMode);
       
  1128 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyUSimAppsSelectionModeChange);
       
  1129 		User::WaitForRequest( reqStatus );
       
  1130 		}
       
  1131 	while( KErrNone == reqStatus.Int() );
       
  1132 	}
       
  1133 
       
  1134 		
       
  1135 /**
       
  1136 * Notify cleanup for RMobilePhone::NotifyUUSSettingChange
       
  1137 */	
       
  1138 void CEtelSessionMgr::CleanupMobilePhoneNotifyUUSSettingChange( 
       
  1139 					RMobilePhone& aMobilePhone )
       
  1140 
       
  1141 	{
       
  1142 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyUUSSettingChange"));
       
  1143 	TRequestStatus reqStatus;
       
  1144 	RMobilePhone::TMobilePhoneUUSSetting setting;
       
  1145 	do 
       
  1146 		{
       
  1147 		aMobilePhone.NotifyUUSSettingChange(reqStatus,setting);
       
  1148 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyUUSSettingChange);
       
  1149 		User::WaitForRequest( reqStatus );
       
  1150 		}
       
  1151 	while( KErrNone == reqStatus.Int() );
       
  1152 	}
       
  1153 
       
  1154 		
       
  1155 /**
       
  1156 * Notify cleanup for RMobilePhone::NotifyIccMessageWaitingIndicatorsChange
       
  1157 */	
       
  1158 void CEtelSessionMgr::CleanupMobilePhoneNotifyIccMessageWaitingIndicatorsChange( 
       
  1159 					RMobilePhone& aMobilePhone )
       
  1160 
       
  1161 	{
       
  1162 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyIccMessageWaitingIndicatorsChange"));
       
  1163 	TRequestStatus reqStatus;
       
  1164 	RMobilePhone::TMobilePhoneMessageWaitingV1 pkgType;
       
  1165 	RMobilePhone::TMobilePhoneMessageWaitingV1Pckg pkgArg(pkgType);
       
  1166 	do 
       
  1167 		{
       
  1168 		aMobilePhone.NotifyIccMessageWaitingIndicatorsChange(reqStatus,pkgArg);
       
  1169 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyIccMessageWaitingIndicatorsChange);
       
  1170 		User::WaitForRequest( reqStatus );
       
  1171 		}
       
  1172 	while( KErrNone == reqStatus.Int() );
       
  1173 	}
       
  1174 
       
  1175 		
       
  1176 /**
       
  1177 * Notify cleanup for RMobilePhone::NotifyMmsConfig
       
  1178 */	
       
  1179 void CEtelSessionMgr::CleanupMobilePhoneNotifyMmsConfig( 
       
  1180 					RMobilePhone& aMobilePhone )
       
  1181 
       
  1182 	{
       
  1183 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMmsConfig"));
       
  1184 	TRequestStatus reqStatus;
       
  1185 	RMobilePhone::TMmsConnParams type = RMobilePhone::EUserPreferences;
       
  1186 	TBuf8<30> connectivity;
       
  1187 	do 
       
  1188 		{
       
  1189 		aMobilePhone.NotifyMmsConfig(reqStatus,type,connectivity);
       
  1190 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMmsConfig);
       
  1191 		User::WaitForRequest( reqStatus );
       
  1192 		}
       
  1193 	while( KErrNone == reqStatus.Int() );
       
  1194 	}
       
  1195 
       
  1196 		
       
  1197 /**
       
  1198 * Notify cleanup for RMobilePhone::NotifyMmsUpdate
       
  1199 */	
       
  1200 void CEtelSessionMgr::CleanupMobilePhoneNotifyMmsUpdate( 
       
  1201 					RMobilePhone& aMobilePhone )
       
  1202 
       
  1203 	{
       
  1204 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMmsUpdate"));
       
  1205 	TRequestStatus reqStatus;
       
  1206 	RMobilePhone::TMmsNotificationV3 pkgType;
       
  1207 	RMobilePhone::TMmsNotificationV3Pckg pkgArg(pkgType);
       
  1208 	do 
       
  1209 		{
       
  1210 		aMobilePhone.NotifyMmsUpdate(reqStatus,pkgArg);
       
  1211 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMmsUpdate);
       
  1212 		User::WaitForRequest( reqStatus );
       
  1213 		}
       
  1214 	while( KErrNone == reqStatus.Int() );
       
  1215 	}
       
  1216 
       
  1217 		
       
  1218 /**
       
  1219 * Notify cleanup for RMobilePhone::NotifyBatteryInfoChange
       
  1220 */	
       
  1221 void CEtelSessionMgr::CleanupMobilePhoneNotifyBatteryInfoChange( 
       
  1222 					RMobilePhone& aMobilePhone )
       
  1223 
       
  1224 	{
       
  1225 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyBatteryInfoChange"));
       
  1226 	TRequestStatus reqStatus;
       
  1227 	RMobilePhone::TMobilePhoneBatteryInfoV1 info;
       
  1228 	do 
       
  1229 		{
       
  1230 		aMobilePhone.NotifyBatteryInfoChange(reqStatus,info);
       
  1231 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyBatteryInfoChange);
       
  1232 		User::WaitForRequest( reqStatus );
       
  1233 		}
       
  1234 	while( KErrNone == reqStatus.Int() );
       
  1235 	}
       
  1236 
       
  1237 		
       
  1238 /**
       
  1239 * Notify cleanup for RMobilePhone::NotifyImsAuthorizationInfoChange
       
  1240 */	
       
  1241 void CEtelSessionMgr::CleanupMobilePhoneNotifyImsAuthorizationInfoChange( 
       
  1242 					RMobilePhone& aMobilePhone )
       
  1243 
       
  1244 	{
       
  1245 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyImsAuthorizationInfoChange"));
       
  1246 	TRequestStatus reqStatus;
       
  1247 	do 
       
  1248 		{
       
  1249 		aMobilePhone.NotifyImsAuthorizationInfoChange(reqStatus);
       
  1250 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyImsAuthorizationInfoChanged);
       
  1251 		User::WaitForRequest( reqStatus );
       
  1252 		}
       
  1253 	while( KErrNone == reqStatus.Int() );
       
  1254 	}
       
  1255 
       
  1256 		
       
  1257 /**
       
  1258 * Notify cleanup for RMobilePhone::NotifySmartCardApplicationInfoChange
       
  1259 */	
       
  1260 void CEtelSessionMgr::CleanupMobilePhoneNotifySmartCardApplicationInfoChange( 
       
  1261 					RMobilePhone& aMobilePhone )
       
  1262 
       
  1263 	{
       
  1264 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifySmartCardApplicationInfoChange"));
       
  1265 	TRequestStatus reqStatus;
       
  1266 	RMobilePhone::TAID aID;
       
  1267 	RMobilePhone::TSmartCardApplicationEvent event;
       
  1268 	do 
       
  1269 		{
       
  1270 		aMobilePhone.NotifySmartCardApplicationInfoChange(reqStatus,aID,event);
       
  1271 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifySmartCardApplicationInfoChange);
       
  1272 		User::WaitForRequest( reqStatus );
       
  1273 		}
       
  1274 	while( KErrNone == reqStatus.Int() );
       
  1275 	}
       
  1276 
       
  1277 		
       
  1278 /**
       
  1279 * Notify cleanup for RMobilePhone::NotifyDefaultPrivacyChange
       
  1280 */	
       
  1281 void CEtelSessionMgr::CleanupMobilePhoneNotifyDefaultPrivacyChange( 
       
  1282 					RMobilePhone& aMobilePhone )
       
  1283 
       
  1284 	{
       
  1285 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyDefaultPrivacyChange"));
       
  1286 	TRequestStatus reqStatus;
       
  1287 	RMobilePhone::TMobilePhonePrivacy setting;
       
  1288 	do 
       
  1289 		{
       
  1290 		aMobilePhone.NotifyDefaultPrivacyChange(reqStatus,setting);
       
  1291 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyDefaultPrivacyChange);
       
  1292 		User::WaitForRequest( reqStatus );
       
  1293 		}
       
  1294 	while( KErrNone == reqStatus.Int() );
       
  1295 	}
       
  1296 
       
  1297 		
       
  1298 /**
       
  1299 * Notify cleanup for RMobilePhone::NotifyAPNListChanged
       
  1300 */	
       
  1301 void CEtelSessionMgr::CleanupMobilePhoneNotifyAPNListChanged( 
       
  1302 					RMobilePhone& aMobilePhone )
       
  1303 
       
  1304 	{
       
  1305 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyAPNListChanged"));
       
  1306 	TRequestStatus reqStatus;
       
  1307 	do 
       
  1308 		{
       
  1309 		aMobilePhone.NotifyAPNListChanged(reqStatus);
       
  1310 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyAPNListChanged);
       
  1311 		User::WaitForRequest( reqStatus );
       
  1312 		}
       
  1313 	while( KErrNone == reqStatus.Int() );
       
  1314 	}
       
  1315 
       
  1316 		
       
  1317 /**
       
  1318 * Notify cleanup for RMobilePhone::NotifyAPNControlListServiceStatusChange
       
  1319 */	
       
  1320 void CEtelSessionMgr::CleanupMobilePhoneNotifyAPNControlListServiceStatusChange( 
       
  1321 					RMobilePhone& aMobilePhone )
       
  1322 
       
  1323 	{
       
  1324 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyAPNControlListServiceStatusChange"));
       
  1325 	TRequestStatus reqStatus;
       
  1326 	RMobilePhone::TAPNControlListServiceStatus aPNControlListServiceStatus;
       
  1327 	do 
       
  1328 		{
       
  1329 		aMobilePhone.NotifyAPNControlListServiceStatusChange(reqStatus,aPNControlListServiceStatus);
       
  1330 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyAPNControlListServiceStatusChange);
       
  1331 		User::WaitForRequest( reqStatus );
       
  1332 		}
       
  1333 	while( KErrNone == reqStatus.Int() );
       
  1334 	}
       
  1335 
       
  1336 		
       
  1337 /**
       
  1338 * Notify cleanup for RMobilePhone::NotifyMailboxNumbersChange
       
  1339 */	
       
  1340 void CEtelSessionMgr::CleanupMobilePhoneNotifyMailboxNumbersChange( 
       
  1341 					RMobilePhone& aMobilePhone )
       
  1342 
       
  1343 	{
       
  1344 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifyMailboxNumbersChange"));
       
  1345 	TRequestStatus reqStatus;
       
  1346 	RMobilePhone::TMobilePhoneVoicemailIdsV3 pkgType;
       
  1347 	RMobilePhone::TMobilePhoneVoicemailIdsV3Pckg pkgArg(pkgType);
       
  1348 	do 
       
  1349 		{
       
  1350 		aMobilePhone.NotifyMailboxNumbersChange(reqStatus,pkgArg);
       
  1351 		aMobilePhone.CancelAsyncRequest(EMobilePhoneNotifyMailboxNumbersChange);
       
  1352 		User::WaitForRequest( reqStatus );
       
  1353 		}
       
  1354 	while( KErrNone == reqStatus.Int() );
       
  1355 	}
       
  1356 
       
  1357 		
       
  1358 /**
       
  1359 * Notify cleanup for RPacketQoS::NotifyProfileChanged
       
  1360 */	
       
  1361 void CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged( 
       
  1362 					RPacketQoS& aPacketQoS )
       
  1363 
       
  1364 	{
       
  1365 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged"));
       
  1366 	TRequestStatus reqStatus;
       
  1367 	RPacketQoS::TQoSGPRSNegotiated pkgType;
       
  1368 	TPckg<RPacketQoS::TQoSGPRSNegotiated> pkgArg(pkgType);
       
  1369 	do 
       
  1370 		{
       
  1371 		aPacketQoS.NotifyProfileChanged(reqStatus,pkgArg);
       
  1372 		aPacketQoS.CancelAsyncRequest(EPacketQoSNotifyProfileChanged);
       
  1373 		User::WaitForRequest( reqStatus );
       
  1374 		}
       
  1375 	while( KErrNone == reqStatus.Int() );
       
  1376 	}
       
  1377 
       
  1378 		
       
  1379 /**
       
  1380 * Notify cleanup for RPacketQoS::NotifyProfileChanged
       
  1381 */	
       
  1382 void CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged1( 
       
  1383 					RPacketQoS& aPacketQoS )
       
  1384 
       
  1385 	{
       
  1386 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged1"));
       
  1387 	TRequestStatus reqStatus;
       
  1388 	RPacketQoS::TQoSR99_R4Negotiated pkgType;
       
  1389 	TPckg<RPacketQoS::TQoSR99_R4Negotiated> pkgArg(pkgType);
       
  1390 	do 
       
  1391 		{
       
  1392 		aPacketQoS.NotifyProfileChanged(reqStatus,pkgArg);
       
  1393 		aPacketQoS.CancelAsyncRequest(EPacketQoSNotifyProfileChanged);
       
  1394 		User::WaitForRequest( reqStatus );
       
  1395 		}
       
  1396 	while( KErrNone == reqStatus.Int() );
       
  1397 	}
       
  1398 
       
  1399 		
       
  1400 /**
       
  1401 * Notify cleanup for RPacketQoS::NotifyProfileChanged
       
  1402 */	
       
  1403 void CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged2( 
       
  1404 					RPacketQoS& aPacketQoS )
       
  1405 
       
  1406 	{
       
  1407 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketQoSNotifyProfileChanged2"));
       
  1408 	TRequestStatus reqStatus;
       
  1409 	RPacketQoS::TQoSR5Negotiated pkgType;
       
  1410 	TPckg<RPacketQoS::TQoSR5Negotiated> pkgArg(pkgType);
       
  1411 	do 
       
  1412 		{
       
  1413 		aPacketQoS.NotifyProfileChanged(reqStatus,pkgArg);
       
  1414 		aPacketQoS.CancelAsyncRequest(EPacketQoSNotifyProfileChanged);
       
  1415 		User::WaitForRequest( reqStatus );
       
  1416 		}
       
  1417 	while( KErrNone == reqStatus.Int() );
       
  1418 	}
       
  1419 
       
  1420 		
       
  1421 /**
       
  1422 * Notify cleanup for RMobileSmartCardEap::NotifyEapMethodAccessStatusChange
       
  1423 */	
       
  1424 void CEtelSessionMgr::CleanupMobileSmartCardEapNotifyEapMethodAccessStatusChange( 
       
  1425 					RMobileSmartCardEap& aMobileSmartCardEap )
       
  1426 
       
  1427 	{
       
  1428 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmartCardEapNotifyEapMethodAccessStatusChange"));
       
  1429 	TRequestStatus reqStatus;
       
  1430 	RMobileSmartCardEap::TEapMethodAccessStatus eapMethodStatus;
       
  1431 	do 
       
  1432 		{
       
  1433 		aMobileSmartCardEap.NotifyEapMethodAccessStatusChange(reqStatus,eapMethodStatus);
       
  1434 		aMobileSmartCardEap.CancelAsyncRequest(EMobileSmartCardEapNotifyEapMethodAccessStatusChange);
       
  1435 		User::WaitForRequest( reqStatus );
       
  1436 		}
       
  1437 	while( KErrNone == reqStatus.Int() );
       
  1438 	}
       
  1439 
       
  1440 		
       
  1441 /**
       
  1442 * Notify cleanup for RMobileSmsMessaging::NotifyMoSmsBearerChange
       
  1443 */	
       
  1444 void CEtelSessionMgr::CleanupMobileSmsMessagingNotifyMoSmsBearerChange( 
       
  1445 					RMobileSmsMessaging& aMobileSmsMessaging )
       
  1446 
       
  1447 	{
       
  1448 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmsMessagingNotifyMoSmsBearerChange"));
       
  1449 	TRequestStatus reqStatus;
       
  1450 	RMobileSmsMessaging::TMobileSmsBearer bearer;
       
  1451 	do 
       
  1452 		{
       
  1453 		aMobileSmsMessaging.NotifyMoSmsBearerChange(reqStatus,bearer);
       
  1454 		aMobileSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifyMoSmsBearerChange);
       
  1455 		User::WaitForRequest( reqStatus );
       
  1456 		}
       
  1457 	while( KErrNone == reqStatus.Int() );
       
  1458 	}
       
  1459 
       
  1460 		
       
  1461 /**
       
  1462 * Notify cleanup for RMobileSmsMessaging::NotifyReceiveModeChange
       
  1463 */	
       
  1464 void CEtelSessionMgr::CleanupMobileSmsMessagingNotifyReceiveModeChange( 
       
  1465 					RMobileSmsMessaging& aMobileSmsMessaging )
       
  1466 
       
  1467 	{
       
  1468 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmsMessagingNotifyReceiveModeChange"));
       
  1469 	TRequestStatus reqStatus;
       
  1470 	RMobileSmsMessaging::TMobileSmsReceiveMode receiveMode;
       
  1471 	do 
       
  1472 		{
       
  1473 		aMobileSmsMessaging.NotifyReceiveModeChange(reqStatus,receiveMode);
       
  1474 		aMobileSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifyReceiveModeChange);
       
  1475 		User::WaitForRequest( reqStatus );
       
  1476 		}
       
  1477 	while( KErrNone == reqStatus.Int() );
       
  1478 	}
       
  1479 
       
  1480 		
       
  1481 /**
       
  1482 * Notify cleanup for RMobileSmsMessaging::NotifySmspListChange
       
  1483 */	
       
  1484 void CEtelSessionMgr::CleanupMobileSmsMessagingNotifySmspListChange( 
       
  1485 					RMobileSmsMessaging& aMobileSmsMessaging )
       
  1486 
       
  1487 	{
       
  1488 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmsMessagingNotifySmspListChange"));
       
  1489 	TRequestStatus reqStatus;
       
  1490 	do 
       
  1491 		{
       
  1492 		aMobileSmsMessaging.NotifySmspListChange(reqStatus);
       
  1493 		aMobileSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifySmspListChange);
       
  1494 		User::WaitForRequest( reqStatus );
       
  1495 		}
       
  1496 	while( KErrNone == reqStatus.Int() );
       
  1497 	}
       
  1498 
       
  1499 		
       
  1500 /**
       
  1501 * Notify cleanup for RMobileCall::NotifyAlternatingCallSwitch
       
  1502 */	
       
  1503 void CEtelSessionMgr::CleanupMobileCallNotifyAlternatingCallSwitch( 
       
  1504 					RMobileCall& aMobileCall )
       
  1505 
       
  1506 	{
       
  1507 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyAlternatingCallSwitch"));
       
  1508 	TRequestStatus reqStatus;
       
  1509 	do 
       
  1510 		{
       
  1511 		aMobileCall.NotifyAlternatingCallSwitch(reqStatus);
       
  1512 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyAlternatingCallSwitch);
       
  1513 		User::WaitForRequest( reqStatus );
       
  1514 		}
       
  1515 	while( KErrNone == reqStatus.Int() );
       
  1516 	}
       
  1517 
       
  1518 		
       
  1519 /**
       
  1520 * Notify cleanup for RMobileCall::NotifyAudioToneEvent
       
  1521 */	
       
  1522 void CEtelSessionMgr::CleanupMobileCallNotifyAudioToneEvent( 
       
  1523 					RMobileCall& aMobileCall )
       
  1524 
       
  1525 	{
       
  1526 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyAudioToneEvent"));
       
  1527 	TRequestStatus reqStatus;
       
  1528 	RMobileCall::TAudioToneV3 pkgType;
       
  1529 	RMobileCall::TAudioToneV3Pckg pkgArg(pkgType);
       
  1530 	do 
       
  1531 		{
       
  1532 		aMobileCall.NotifyAudioToneEvent(reqStatus,pkgArg);
       
  1533 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyAudioToneEvent);
       
  1534 		User::WaitForRequest( reqStatus );
       
  1535 		}
       
  1536 	while( KErrNone == reqStatus.Int() );
       
  1537 	}
       
  1538 
       
  1539 		
       
  1540 /**
       
  1541 * Notify cleanup for RMobileCall::NotifyCallEvent
       
  1542 */	
       
  1543 void CEtelSessionMgr::CleanupMobileCallNotifyCallEvent( 
       
  1544 					RMobileCall& aMobileCall )
       
  1545 
       
  1546 	{
       
  1547 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyCallEvent"));
       
  1548 	TRequestStatus reqStatus;
       
  1549 	RMobileCall::TMobileCallEvent event;
       
  1550 	do 
       
  1551 		{
       
  1552 		aMobileCall.NotifyCallEvent(reqStatus,event);
       
  1553 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyCallEvent);
       
  1554 		User::WaitForRequest( reqStatus );
       
  1555 		}
       
  1556 	while( KErrNone == reqStatus.Int() );
       
  1557 	}
       
  1558 
       
  1559 		
       
  1560 /**
       
  1561 * Notify cleanup for RMobileCall::NotifyHscsdInfoChange
       
  1562 */	
       
  1563 void CEtelSessionMgr::CleanupMobileCallNotifyHscsdInfoChange( 
       
  1564 					RMobileCall& aMobileCall )
       
  1565 
       
  1566 	{
       
  1567 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyHscsdInfoChange"));
       
  1568 	TRequestStatus reqStatus;
       
  1569 	RMobileCall::TMobileCallHscsdInfoV1 pkgType;
       
  1570 	RMobileCall::TMobileCallHscsdInfoV1Pckg pkgArg(pkgType);
       
  1571 	do 
       
  1572 		{
       
  1573 		aMobileCall.NotifyHscsdInfoChange(reqStatus,pkgArg);
       
  1574 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyHscsdInfoChange);
       
  1575 		User::WaitForRequest( reqStatus );
       
  1576 		}
       
  1577 	while( KErrNone == reqStatus.Int() );
       
  1578 	}
       
  1579 
       
  1580 		
       
  1581 /**
       
  1582 * Notify cleanup for RMobileCall::NotifyMobileCallCapsChange
       
  1583 */	
       
  1584 void CEtelSessionMgr::CleanupMobileCallNotifyMobileCallCapsChange( 
       
  1585 					RMobileCall& aMobileCall )
       
  1586 
       
  1587 	{
       
  1588 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyMobileCallCapsChange"));
       
  1589 	TRequestStatus reqStatus;
       
  1590 	RMobileCall::TMobileCallCapsV1 pkgType;
       
  1591 	RMobileCall::TMobileCallCapsV1Pckg pkgArg(pkgType);
       
  1592 	do 
       
  1593 		{
       
  1594 		aMobileCall.NotifyMobileCallCapsChange(reqStatus,pkgArg);
       
  1595 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);
       
  1596 		User::WaitForRequest( reqStatus );
       
  1597 		}
       
  1598 	while( KErrNone == reqStatus.Int() );
       
  1599 	}
       
  1600 
       
  1601 		
       
  1602 /**
       
  1603 * Notify cleanup for RMobileCall::NotifyMobileCallStatusChange
       
  1604 */	
       
  1605 void CEtelSessionMgr::CleanupMobileCallNotifyMobileCallStatusChange( 
       
  1606 					RMobileCall& aMobileCall )
       
  1607 
       
  1608 	{
       
  1609 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyMobileCallStatusChange"));
       
  1610 	TRequestStatus reqStatus;
       
  1611 	RMobileCall::TMobileCallStatus status;
       
  1612 	do 
       
  1613 		{
       
  1614 		aMobileCall.NotifyMobileCallStatusChange(reqStatus,status);
       
  1615 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
       
  1616 		User::WaitForRequest( reqStatus );
       
  1617 		}
       
  1618 	while( KErrNone == reqStatus.Int() );
       
  1619 	}
       
  1620 
       
  1621 		
       
  1622 /**
       
  1623 * Notify cleanup for RMobileCall::NotifyMobileDataCallCapsChange
       
  1624 */	
       
  1625 void CEtelSessionMgr::CleanupMobileCallNotifyMobileDataCallCapsChange( 
       
  1626 					RMobileCall& aMobileCall )
       
  1627 
       
  1628 	{
       
  1629 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyMobileDataCallCapsChange"));
       
  1630 	TRequestStatus reqStatus;
       
  1631 	RMobileCall::TMobileCallDataCapsV1 pkgType;
       
  1632 	RMobileCall::TMobileCallDataCapsV1Pckg pkgArg(pkgType);
       
  1633 	do 
       
  1634 		{
       
  1635 		aMobileCall.NotifyMobileDataCallCapsChange(reqStatus,pkgArg);
       
  1636 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyMobileDataCallCapsChange);
       
  1637 		User::WaitForRequest( reqStatus );
       
  1638 		}
       
  1639 	while( KErrNone == reqStatus.Int() );
       
  1640 	}
       
  1641 
       
  1642 		
       
  1643 /**
       
  1644 * Notify cleanup for RMobileCall::NotifyUUSCapsChange
       
  1645 */	
       
  1646 void CEtelSessionMgr::CleanupMobileCallNotifyUUSCapsChange( 
       
  1647 					RMobileCall& aMobileCall )
       
  1648 
       
  1649 	{
       
  1650 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyUUSCapsChange"));
       
  1651 	TRequestStatus reqStatus;
       
  1652 	TUint32 caps;
       
  1653 	do 
       
  1654 		{
       
  1655 		aMobileCall.NotifyUUSCapsChange(reqStatus,caps);
       
  1656 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyUUSCapsChange);
       
  1657 		User::WaitForRequest( reqStatus );
       
  1658 		}
       
  1659 	while( KErrNone == reqStatus.Int() );
       
  1660 	}
       
  1661 
       
  1662 		
       
  1663 /**
       
  1664 * Notify cleanup for RMobileCall::NotifyVoiceFallback
       
  1665 */	
       
  1666 void CEtelSessionMgr::CleanupMobileCallNotifyVoiceFallback( 
       
  1667 					RMobileCall& aMobileCall )
       
  1668 
       
  1669 	{
       
  1670 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyVoiceFallback"));
       
  1671 	TRequestStatus reqStatus;
       
  1672 	TName callName;
       
  1673 	do 
       
  1674 		{
       
  1675 		aMobileCall.NotifyVoiceFallback(reqStatus,callName);
       
  1676 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyVoiceFallback);
       
  1677 		User::WaitForRequest( reqStatus );
       
  1678 		}
       
  1679 	while( KErrNone == reqStatus.Int() );
       
  1680 	}
       
  1681 
       
  1682 		
       
  1683 /**
       
  1684 * Notify cleanup for RMobileCall::NotifyPrivacyConfirmation
       
  1685 */	
       
  1686 void CEtelSessionMgr::CleanupMobileCallNotifyPrivacyConfirmation( 
       
  1687 					RMobileCall& aMobileCall )
       
  1688 
       
  1689 	{
       
  1690 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyPrivacyConfirmation"));
       
  1691 	TRequestStatus reqStatus;
       
  1692 	RMobilePhone::TMobilePhonePrivacy privacySetting;
       
  1693 	do 
       
  1694 		{
       
  1695 		aMobileCall.NotifyPrivacyConfirmation(reqStatus,privacySetting);
       
  1696 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyPrivacyConfirmation);
       
  1697 		User::WaitForRequest( reqStatus );
       
  1698 		}
       
  1699 	while( KErrNone == reqStatus.Int() );
       
  1700 	}
       
  1701 
       
  1702 		
       
  1703 /**
       
  1704 * Notify cleanup for RMobileCall::NotifyTrafficChannelConfirmation
       
  1705 */	
       
  1706 void CEtelSessionMgr::CleanupMobileCallNotifyTrafficChannelConfirmation( 
       
  1707 					RMobileCall& aMobileCall )
       
  1708 
       
  1709 	{
       
  1710 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyTrafficChannelConfirmation"));
       
  1711 	TRequestStatus reqStatus;
       
  1712 	RMobileCall::TMobileCallTch tchType;
       
  1713 	do 
       
  1714 		{
       
  1715 		aMobileCall.NotifyTrafficChannelConfirmation(reqStatus,tchType);
       
  1716 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyTrafficChannelConfirmation);
       
  1717 		User::WaitForRequest( reqStatus );
       
  1718 		}
       
  1719 	while( KErrNone == reqStatus.Int() );
       
  1720 	}
       
  1721 
       
  1722 		
       
  1723 /**
       
  1724 * Notify cleanup for RMobileCall::NotifyRemotePartyInfoChange
       
  1725 */	
       
  1726 void CEtelSessionMgr::CleanupMobileCallNotifyRemotePartyInfoChange( 
       
  1727 					RMobileCall& aMobileCall )
       
  1728 
       
  1729 	{
       
  1730 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifyRemotePartyInfoChange"));
       
  1731 	TRequestStatus reqStatus;
       
  1732 	RMobileCall::TMobileCallRemotePartyInfoV1 pkgType;
       
  1733 	RMobileCall::TMobileCallRemotePartyInfoV1Pckg pkgArg(pkgType);
       
  1734 	do 
       
  1735 		{
       
  1736 		aMobileCall.NotifyRemotePartyInfoChange(reqStatus,pkgArg);
       
  1737 		aMobileCall.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);
       
  1738 		User::WaitForRequest( reqStatus );
       
  1739 		}
       
  1740 	while( KErrNone == reqStatus.Int() );
       
  1741 	}
       
  1742 
       
  1743 		
       
  1744 /**
       
  1745 * Notify cleanup for RLine::NotifyCapsChange
       
  1746 */	
       
  1747 void CEtelSessionMgr::CleanupLineNotifyCapsChange( 
       
  1748 					RLine& aLine )
       
  1749 
       
  1750 	{
       
  1751 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifyCapsChange"));
       
  1752 	TRequestStatus reqStatus;
       
  1753 	RLine::TCaps caps;
       
  1754 	do 
       
  1755 		{
       
  1756 		aLine.NotifyCapsChange(reqStatus,caps);
       
  1757 		aLine.NotifyCapsChangeCancel();
       
  1758 		User::WaitForRequest( reqStatus );
       
  1759 		}
       
  1760 	while( KErrNone == reqStatus.Int() );
       
  1761 	}
       
  1762 
       
  1763 		
       
  1764 /**
       
  1765 * Notify cleanup for RLine::NotifyCallAdded
       
  1766 */	
       
  1767 void CEtelSessionMgr::CleanupLineNotifyCallAdded( 
       
  1768 					RLine& aLine )
       
  1769 
       
  1770 	{
       
  1771 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifyCallAdded"));
       
  1772 	TRequestStatus reqStatus;
       
  1773 	TName name;
       
  1774 	do 
       
  1775 		{
       
  1776 		aLine.NotifyCallAdded(reqStatus,name);
       
  1777 		aLine.NotifyCallAddedCancel();
       
  1778 		User::WaitForRequest( reqStatus );
       
  1779 		}
       
  1780 	while( KErrNone == reqStatus.Int() );
       
  1781 	}
       
  1782 
       
  1783 		
       
  1784 /**
       
  1785 * Notify cleanup for RLine::NotifyHookChange
       
  1786 */	
       
  1787 void CEtelSessionMgr::CleanupLineNotifyHookChange( 
       
  1788 					RLine& aLine )
       
  1789 
       
  1790 	{
       
  1791 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifyHookChange"));
       
  1792 	TRequestStatus reqStatus;
       
  1793 	RCall::THookStatus hookStatus;
       
  1794 	do 
       
  1795 		{
       
  1796 		aLine.NotifyHookChange(reqStatus,hookStatus);
       
  1797 		aLine.NotifyHookChangeCancel();
       
  1798 		User::WaitForRequest( reqStatus );
       
  1799 		}
       
  1800 	while( KErrNone == reqStatus.Int() );
       
  1801 	}
       
  1802 
       
  1803 		
       
  1804 /**
       
  1805 * Notify cleanup for RLine::NotifyStatusChange
       
  1806 */	
       
  1807 void CEtelSessionMgr::CleanupLineNotifyStatusChange( 
       
  1808 					RLine& aLine )
       
  1809 
       
  1810 	{
       
  1811 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifyStatusChange"));
       
  1812 	TRequestStatus reqStatus;
       
  1813 	RCall::TStatus lineStatus;
       
  1814 	do 
       
  1815 		{
       
  1816 		aLine.NotifyStatusChange(reqStatus,lineStatus);
       
  1817 		aLine.NotifyStatusChangeCancel();
       
  1818 		User::WaitForRequest( reqStatus );
       
  1819 		}
       
  1820 	while( KErrNone == reqStatus.Int() );
       
  1821 	}
       
  1822 
       
  1823 		
       
  1824 /**
       
  1825 * Notify cleanup for RLine::NotifyIncomingCall
       
  1826 */	
       
  1827 void CEtelSessionMgr::CleanupLineNotifyIncomingCall( 
       
  1828 					RLine& aLine )
       
  1829 
       
  1830 	{
       
  1831 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifyIncomingCall"));
       
  1832 	TRequestStatus reqStatus;
       
  1833 	TName name;
       
  1834 	do 
       
  1835 		{
       
  1836 		aLine.NotifyIncomingCall(reqStatus,name);
       
  1837 		aLine.NotifyIncomingCallCancel();
       
  1838 		User::WaitForRequest( reqStatus );
       
  1839 		}
       
  1840 	while( KErrNone == reqStatus.Int() );
       
  1841 	}
       
  1842 
       
  1843 		
       
  1844 /**
       
  1845 * Notify cleanup for RMobilePhoneStore::NotifyStoreEvent
       
  1846 */	
       
  1847 void CEtelSessionMgr::CleanupMobilePhoneStoreNotifyStoreEvent( 
       
  1848 					RMobilePhoneStore& aMobilePhoneStore )
       
  1849 
       
  1850 	{
       
  1851 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneStoreNotifyStoreEvent"));
       
  1852 	TRequestStatus reqStatus;
       
  1853 	TUint32 event;
       
  1854 	TInt index;
       
  1855 	do 
       
  1856 		{
       
  1857 		aMobilePhoneStore.NotifyStoreEvent(reqStatus,event,index);
       
  1858 		aMobilePhoneStore.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);
       
  1859 		User::WaitForRequest( reqStatus );
       
  1860 		}
       
  1861 	while( KErrNone == reqStatus.Int() );
       
  1862 	}
       
  1863 
       
  1864 		
       
  1865 /**
       
  1866 * Notify cleanup for RMobileConferenceCall::NotifyCapsChange
       
  1867 */	
       
  1868 void CEtelSessionMgr::CleanupMobileConferenceCallNotifyCapsChange( 
       
  1869 					RMobileConferenceCall& aMobileConferenceCall )
       
  1870 
       
  1871 	{
       
  1872 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileConferenceCallNotifyCapsChange"));
       
  1873 	TRequestStatus reqStatus;
       
  1874 	TUint32 caps;
       
  1875 	do 
       
  1876 		{
       
  1877 		aMobileConferenceCall.NotifyCapsChange(reqStatus,caps);
       
  1878 		aMobileConferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyCapsChange);
       
  1879 		User::WaitForRequest( reqStatus );
       
  1880 		}
       
  1881 	while( KErrNone == reqStatus.Int() );
       
  1882 	}
       
  1883 
       
  1884 		
       
  1885 /**
       
  1886 * Notify cleanup for RMobileConferenceCall::NotifyConferenceEvent
       
  1887 */	
       
  1888 void CEtelSessionMgr::CleanupMobileConferenceCallNotifyConferenceEvent( 
       
  1889 					RMobileConferenceCall& aMobileConferenceCall )
       
  1890 
       
  1891 	{
       
  1892 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileConferenceCallNotifyConferenceEvent"));
       
  1893 	TRequestStatus reqStatus;
       
  1894 	RMobileConferenceCall::TMobileConferenceEvent event;
       
  1895 	TName callName;
       
  1896 	do 
       
  1897 		{
       
  1898 		aMobileConferenceCall.NotifyConferenceEvent(reqStatus,event,callName);
       
  1899 		aMobileConferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyConferenceEvent);
       
  1900 		User::WaitForRequest( reqStatus );
       
  1901 		}
       
  1902 	while( KErrNone == reqStatus.Int() );
       
  1903 	}
       
  1904 
       
  1905 		
       
  1906 /**
       
  1907 * Notify cleanup for RMobileConferenceCall::NotifyConferenceStatusChange
       
  1908 */	
       
  1909 void CEtelSessionMgr::CleanupMobileConferenceCallNotifyConferenceStatusChange( 
       
  1910 					RMobileConferenceCall& aMobileConferenceCall )
       
  1911 
       
  1912 	{
       
  1913 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileConferenceCallNotifyConferenceStatusChange"));
       
  1914 	TRequestStatus reqStatus;
       
  1915 	RMobileConferenceCall::TMobileConferenceStatus status;
       
  1916 	do 
       
  1917 		{
       
  1918 		aMobileConferenceCall.NotifyConferenceStatusChange(reqStatus,status);
       
  1919 		aMobileConferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyConferenceStatusChange);
       
  1920 		User::WaitForRequest( reqStatus );
       
  1921 		}
       
  1922 	while( KErrNone == reqStatus.Int() );
       
  1923 	}
       
  1924 
       
  1925 		
       
  1926 /**
       
  1927 * Notify cleanup for RPacketContext::NotifyConnectionSpeedChange
       
  1928 */	
       
  1929 void CEtelSessionMgr::CleanupPacketContextNotifyConnectionSpeedChange( 
       
  1930 					RPacketContext& aPacketContext )
       
  1931 
       
  1932 	{
       
  1933 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyConnectionSpeedChange"));
       
  1934 	TRequestStatus reqStatus;
       
  1935 	TUint rate;
       
  1936 	do 
       
  1937 		{
       
  1938 		aPacketContext.NotifyConnectionSpeedChange(reqStatus,rate);
       
  1939 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyConnectionSpeedChange);
       
  1940 		User::WaitForRequest( reqStatus );
       
  1941 		}
       
  1942 	while( KErrNone == reqStatus.Int() );
       
  1943 	}
       
  1944 
       
  1945 		
       
  1946 /**
       
  1947 * Notify cleanup for RPacketContext::NotifyStatusChange
       
  1948 */	
       
  1949 void CEtelSessionMgr::CleanupPacketContextNotifyStatusChange( 
       
  1950 					RPacketContext& aPacketContext )
       
  1951 
       
  1952 	{
       
  1953 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyStatusChange"));
       
  1954 	TRequestStatus reqStatus;
       
  1955 	RPacketContext::TContextStatus contextStatus;
       
  1956 	do 
       
  1957 		{
       
  1958 		aPacketContext.NotifyStatusChange(reqStatus,contextStatus);
       
  1959 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyStatusChange);
       
  1960 		User::WaitForRequest( reqStatus );
       
  1961 		}
       
  1962 	while( KErrNone == reqStatus.Int() );
       
  1963 	}
       
  1964 
       
  1965 		
       
  1966 /**
       
  1967 * Notify cleanup for RPacketContext::NotifyConfigChanged
       
  1968 */	
       
  1969 void CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged( 
       
  1970 					RPacketContext& aPacketContext )
       
  1971 
       
  1972 	{
       
  1973 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged"));
       
  1974 	TRequestStatus reqStatus;
       
  1975 	RPacketContext::TContextConfigGPRS pkgType;
       
  1976 	TPckg<RPacketContext::TContextConfigGPRS> pkgArg(pkgType);
       
  1977 	do 
       
  1978 		{
       
  1979 		aPacketContext.NotifyConfigChanged(reqStatus,pkgArg);
       
  1980 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyConfigChanged);
       
  1981 		User::WaitForRequest( reqStatus );
       
  1982 		}
       
  1983 	while( KErrNone == reqStatus.Int() );
       
  1984 	}
       
  1985 
       
  1986 		
       
  1987 /**
       
  1988 * Notify cleanup for RPacketContext::NotifyConfigChanged
       
  1989 */	
       
  1990 void CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged1( 
       
  1991 					RPacketContext& aPacketContext )
       
  1992 
       
  1993 	{
       
  1994 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged1"));
       
  1995 	TRequestStatus reqStatus;
       
  1996 	RPacketContext::TContextConfigR99_R4 pkgType;
       
  1997 	TPckg<RPacketContext::TContextConfigR99_R4> pkgArg(pkgType);
       
  1998 	do 
       
  1999 		{
       
  2000 		aPacketContext.NotifyConfigChanged(reqStatus,pkgArg);
       
  2001 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyConfigChanged);
       
  2002 		User::WaitForRequest( reqStatus );
       
  2003 		}
       
  2004 	while( KErrNone == reqStatus.Int() );
       
  2005 	}
       
  2006 
       
  2007 		
       
  2008 /**
       
  2009 * Notify cleanup for RPacketContext::NotifyConfigChanged
       
  2010 */	
       
  2011 void CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged2( 
       
  2012 					RPacketContext& aPacketContext )
       
  2013 
       
  2014 	{
       
  2015 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyConfigChanged2"));
       
  2016 	TRequestStatus reqStatus;
       
  2017 	RPacketContext::TContextConfig_R5 pkgType;
       
  2018 	TPckg<RPacketContext::TContextConfig_R5> pkgArg(pkgType);
       
  2019 	do 
       
  2020 		{
       
  2021 		aPacketContext.NotifyConfigChanged(reqStatus,pkgArg);
       
  2022 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyConfigChanged);
       
  2023 		User::WaitForRequest( reqStatus );
       
  2024 		}
       
  2025 	while( KErrNone == reqStatus.Int() );
       
  2026 	}
       
  2027 
       
  2028 		
       
  2029 /**
       
  2030 * Notify cleanup for RPacketContext::NotifyDataTransferred
       
  2031 */	
       
  2032 void CEtelSessionMgr::CleanupPacketContextNotifyDataTransferred( 
       
  2033 					RPacketContext& aPacketContext )
       
  2034 
       
  2035 	{
       
  2036 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifyDataTransferred"));
       
  2037 	TRequestStatus reqStatus;
       
  2038 	RPacketContext::TDataVolume volume;
       
  2039 	TUint rcvdGranularity=0x1000;
       
  2040 	TUint sentGranularity=0x1000;
       
  2041 	do 
       
  2042 		{
       
  2043 		aPacketContext.NotifyDataTransferred(reqStatus,volume,rcvdGranularity,sentGranularity);
       
  2044 		aPacketContext.CancelAsyncRequest(EPacketContextNotifyDataTransferred);
       
  2045 		User::WaitForRequest( reqStatus );
       
  2046 		}
       
  2047 	while( KErrNone == reqStatus.Int() );
       
  2048 	}
       
  2049 
       
  2050 		
       
  2051 /**
       
  2052 * Notify cleanup for RMobileUssdMessaging::NotifyNetworkRelease
       
  2053 */	
       
  2054 void CEtelSessionMgr::CleanupMobileUssdMessagingNotifyNetworkRelease( 
       
  2055 					RMobileUssdMessaging& aMobileUssdMessaging )
       
  2056 
       
  2057 	{
       
  2058 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileUssdMessagingNotifyNetworkRelease"));
       
  2059 	TRequestStatus reqStatus;
       
  2060 	RMobileUssdMessaging::TMobileUssdAttributesV1 pkgType;
       
  2061 	RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pkgArg(pkgType);
       
  2062 	RMobilePhone::TMobilePhoneSendSSRequestV3 pkg1;
       
  2063 	RMobilePhone::TMobilePhoneSendSSRequestV3Pckg pkgArg1(pkg1);
       
  2064 	do 
       
  2065 		{
       
  2066 		aMobileUssdMessaging.NotifyNetworkRelease(reqStatus,pkgArg1,pkgArg);
       
  2067 		aMobileUssdMessaging.CancelAsyncRequest(EMobileUssdMessagingNotifyNetworkRelease);
       
  2068 		User::WaitForRequest( reqStatus );
       
  2069 		}
       
  2070 	while( KErrNone == reqStatus.Int() );
       
  2071 	}
       
  2072 
       
  2073 		
       
  2074 /**
       
  2075 * Notify cleanup for RPacketService::NotifyAttachModeChange
       
  2076 */	
       
  2077 void CEtelSessionMgr::CleanupPacketServiceNotifyAttachModeChange( 
       
  2078 					RPacketService& aPacketService )
       
  2079 
       
  2080 	{
       
  2081 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyAttachModeChange"));
       
  2082 	TRequestStatus reqStatus;
       
  2083 	RPacketService::TAttachMode mode;
       
  2084 	do 
       
  2085 		{
       
  2086 		aPacketService.NotifyAttachModeChange(reqStatus,mode);
       
  2087 		aPacketService.CancelAsyncRequest(EPacketNotifyAttachModeChange);
       
  2088 		User::WaitForRequest( reqStatus );
       
  2089 		}
       
  2090 	while( KErrNone == reqStatus.Int() );
       
  2091 	}
       
  2092 
       
  2093 		
       
  2094 /**
       
  2095 * Notify cleanup for RPacketService::NotifyChangeOfNtwkRegStatus
       
  2096 */	
       
  2097 void CEtelSessionMgr::CleanupPacketServiceNotifyChangeOfNtwkRegStatus( 
       
  2098 					RPacketService& aPacketService )
       
  2099 
       
  2100 	{
       
  2101 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyChangeOfNtwkRegStatus"));
       
  2102 	TRequestStatus reqStatus;
       
  2103 	RPacketService::TRegistrationStatus registrationStatus;
       
  2104 	do 
       
  2105 		{
       
  2106 		aPacketService.NotifyChangeOfNtwkRegStatus(reqStatus,registrationStatus);
       
  2107 		aPacketService.CancelAsyncRequest(EPacketNotifyChangeOfNtwkRegStatus);
       
  2108 		User::WaitForRequest( reqStatus );
       
  2109 		}
       
  2110 	while( KErrNone == reqStatus.Int() );
       
  2111 	}
       
  2112 
       
  2113 		
       
  2114 /**
       
  2115 * Notify cleanup for RPacketService::NotifyContextActivationRequested
       
  2116 */	
       
  2117 void CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested( 
       
  2118 					RPacketService& aPacketService )
       
  2119 
       
  2120 	{
       
  2121 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested"));
       
  2122 	TRequestStatus reqStatus;
       
  2123 	RPacketContext::TContextConfigGPRS pkgType;
       
  2124 	TPckg<RPacketContext::TContextConfigGPRS> pkgArg(pkgType);
       
  2125 	do 
       
  2126 		{
       
  2127 		aPacketService.NotifyContextActivationRequested(reqStatus,pkgArg);
       
  2128 		aPacketService.CancelAsyncRequest(EPacketNotifyContextActivationRequested);
       
  2129 		User::WaitForRequest( reqStatus );
       
  2130 		}
       
  2131 	while( KErrNone == reqStatus.Int() );
       
  2132 	}
       
  2133 
       
  2134 		
       
  2135 /**
       
  2136 * Notify cleanup for RPacketService::NotifyContextActivationRequested
       
  2137 */	
       
  2138 void CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested1( 
       
  2139 					RPacketService& aPacketService )
       
  2140 
       
  2141 	{
       
  2142 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested1"));
       
  2143 	TRequestStatus reqStatus;
       
  2144 	RPacketContext::TContextConfigR99_R4 pkgType;
       
  2145 	TPckg<RPacketContext::TContextConfigR99_R4> pkgArg(pkgType);
       
  2146 	do 
       
  2147 		{
       
  2148 		aPacketService.NotifyContextActivationRequested(reqStatus,pkgArg);
       
  2149 		aPacketService.CancelAsyncRequest(EPacketNotifyContextActivationRequested);
       
  2150 		User::WaitForRequest( reqStatus );
       
  2151 		}
       
  2152 	while( KErrNone == reqStatus.Int() );
       
  2153 	}
       
  2154 
       
  2155 		
       
  2156 /**
       
  2157 * Notify cleanup for RPacketService::NotifyContextActivationRequested
       
  2158 */	
       
  2159 void CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested2( 
       
  2160 					RPacketService& aPacketService )
       
  2161 
       
  2162 	{
       
  2163 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyContextActivationRequested2"));
       
  2164 	TRequestStatus reqStatus;
       
  2165 	RPacketContext::TContextConfig_R5 pkgType;
       
  2166 	TPckg<RPacketContext::TContextConfig_R5> pkgArg(pkgType);
       
  2167 	do 
       
  2168 		{
       
  2169 		aPacketService.NotifyContextActivationRequested(reqStatus,pkgArg);
       
  2170 		aPacketService.CancelAsyncRequest(EPacketNotifyContextActivationRequested);
       
  2171 		User::WaitForRequest( reqStatus );
       
  2172 		}
       
  2173 	while( KErrNone == reqStatus.Int() );
       
  2174 	}
       
  2175 
       
  2176 		
       
  2177 /**
       
  2178 * Notify cleanup for RPacketService::NotifyContextAdded
       
  2179 */	
       
  2180 void CEtelSessionMgr::CleanupPacketServiceNotifyContextAdded( 
       
  2181 					RPacketService& aPacketService )
       
  2182 
       
  2183 	{
       
  2184 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyContextAdded"));
       
  2185 	TRequestStatus reqStatus;
       
  2186 	TBuf16<20> contextId;
       
  2187 	do 
       
  2188 		{
       
  2189 		aPacketService.NotifyContextAdded(reqStatus,contextId);
       
  2190 		aPacketService.CancelAsyncRequest(EPacketNotifyContextAdded);
       
  2191 		User::WaitForRequest( reqStatus );
       
  2192 		}
       
  2193 	while( KErrNone == reqStatus.Int() );
       
  2194 	}
       
  2195 
       
  2196 		
       
  2197 /**
       
  2198 * Notify cleanup for RPacketService::NotifyDynamicCapsChange
       
  2199 */	
       
  2200 void CEtelSessionMgr::CleanupPacketServiceNotifyDynamicCapsChange( 
       
  2201 					RPacketService& aPacketService )
       
  2202 
       
  2203 	{
       
  2204 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyDynamicCapsChange"));
       
  2205 	TRequestStatus reqStatus;
       
  2206 	RPacketService::TDynamicCapsFlags caps;
       
  2207 	do 
       
  2208 		{
       
  2209 		aPacketService.NotifyDynamicCapsChange(reqStatus,caps);
       
  2210 		aPacketService.CancelAsyncRequest(EPacketNotifyDynamicCapsChange);
       
  2211 		User::WaitForRequest( reqStatus );
       
  2212 		}
       
  2213 	while( KErrNone == reqStatus.Int() );
       
  2214 	}
       
  2215 
       
  2216 		
       
  2217 /**
       
  2218 * Notify cleanup for RPacketService::NotifyMSClassChange
       
  2219 */	
       
  2220 void CEtelSessionMgr::CleanupPacketServiceNotifyMSClassChange( 
       
  2221 					RPacketService& aPacketService )
       
  2222 
       
  2223 	{
       
  2224 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyMSClassChange"));
       
  2225 	TRequestStatus reqStatus;
       
  2226 	RPacketService::TMSClass newClass;
       
  2227 	do 
       
  2228 		{
       
  2229 		aPacketService.NotifyMSClassChange(reqStatus,newClass);
       
  2230 		aPacketService.CancelAsyncRequest(EPacketNotifyMSClassChange);
       
  2231 		User::WaitForRequest( reqStatus );
       
  2232 		}
       
  2233 	while( KErrNone == reqStatus.Int() );
       
  2234 	}
       
  2235 
       
  2236 		
       
  2237 /**
       
  2238 * Notify cleanup for RPacketService::NotifyReleaseModeChange
       
  2239 */	
       
  2240 void CEtelSessionMgr::CleanupPacketServiceNotifyReleaseModeChange( 
       
  2241 					RPacketService& aPacketService )
       
  2242 
       
  2243 	{
       
  2244 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyReleaseModeChange"));
       
  2245 	TRequestStatus reqStatus;
       
  2246 	RPacketService::TPacketReleaseMode releaseMode;
       
  2247 	do 
       
  2248 		{
       
  2249 		aPacketService.NotifyReleaseModeChange(reqStatus,releaseMode);
       
  2250 		aPacketService.CancelAsyncRequest(EPacketNotifyReleaseModeChange);
       
  2251 		User::WaitForRequest( reqStatus );
       
  2252 		}
       
  2253 	while( KErrNone == reqStatus.Int() );
       
  2254 	}
       
  2255 
       
  2256 		
       
  2257 /**
       
  2258 * Notify cleanup for RPacketService::NotifyStatusChange
       
  2259 */	
       
  2260 void CEtelSessionMgr::CleanupPacketServiceNotifyStatusChange( 
       
  2261 					RPacketService& aPacketService )
       
  2262 
       
  2263 	{
       
  2264 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifyStatusChange"));
       
  2265 	TRequestStatus reqStatus;
       
  2266 	RPacketService::TStatus packetStatus;
       
  2267 	do 
       
  2268 		{
       
  2269 		aPacketService.NotifyStatusChange(reqStatus,packetStatus);
       
  2270 		aPacketService.CancelAsyncRequest(EPacketNotifyStatusChange);
       
  2271 		User::WaitForRequest( reqStatus );
       
  2272 		}
       
  2273 	while( KErrNone == reqStatus.Int() );
       
  2274 	}
       
  2275 
       
  2276 		
       
  2277 /**
       
  2278 * Notify cleanup for RCall::NotifyCapsChange
       
  2279 */	
       
  2280 void CEtelSessionMgr::CleanupCallNotifyCapsChange( 
       
  2281 					RCall& aCall )
       
  2282 
       
  2283 	{
       
  2284 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupCallNotifyCapsChange"));
       
  2285 	TRequestStatus reqStatus;
       
  2286 	RCall::TCaps caps;
       
  2287 	do 
       
  2288 		{
       
  2289 		aCall.NotifyCapsChange(reqStatus,caps);
       
  2290 		aCall.NotifyCapsChangeCancel();
       
  2291 		User::WaitForRequest( reqStatus );
       
  2292 		}
       
  2293 	while( KErrNone == reqStatus.Int() );
       
  2294 	}
       
  2295 
       
  2296 		
       
  2297 /**
       
  2298 * Notify cleanup for RCall::NotifyCallDurationChange
       
  2299 */	
       
  2300 void CEtelSessionMgr::CleanupCallNotifyCallDurationChange( 
       
  2301 					RCall& aCall )
       
  2302 
       
  2303 	{
       
  2304 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupCallNotifyCallDurationChange"));
       
  2305 	TRequestStatus reqStatus;
       
  2306 	TTimeIntervalSeconds time;
       
  2307 	do 
       
  2308 		{
       
  2309 		aCall.NotifyCallDurationChange(reqStatus,time);
       
  2310 		aCall.NotifyCallDurationChangeCancel();
       
  2311 		User::WaitForRequest( reqStatus );
       
  2312 		}
       
  2313 	while( KErrNone == reqStatus.Int() );
       
  2314 	}
       
  2315 
       
  2316 		
       
  2317 /**
       
  2318 * Notify cleanup for RCall::NotifyHookChange
       
  2319 */	
       
  2320 void CEtelSessionMgr::CleanupCallNotifyHookChange( 
       
  2321 					RCall& aCall )
       
  2322 
       
  2323 	{
       
  2324 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupCallNotifyHookChange"));
       
  2325 	TRequestStatus reqStatus;
       
  2326 	RCall::THookStatus hookStatus;
       
  2327 	do 
       
  2328 		{
       
  2329 		aCall.NotifyHookChange(reqStatus,hookStatus);
       
  2330 		aCall.NotifyHookChangeCancel();
       
  2331 		User::WaitForRequest( reqStatus );
       
  2332 		}
       
  2333 	while( KErrNone == reqStatus.Int() );
       
  2334 	}
       
  2335 
       
  2336 		
       
  2337 /**
       
  2338 * Notify cleanup for RCall::NotifyStatusChange
       
  2339 */	
       
  2340 void CEtelSessionMgr::CleanupCallNotifyStatusChange( 
       
  2341 					RCall& aCall )
       
  2342 
       
  2343 	{
       
  2344 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupCallNotifyStatusChange"));
       
  2345 	TRequestStatus reqStatus;
       
  2346 	RCall::TStatus callStatus;
       
  2347 	do 
       
  2348 		{
       
  2349 		aCall.NotifyStatusChange(reqStatus,callStatus);
       
  2350 		aCall.NotifyStatusChangeCancel();
       
  2351 		User::WaitForRequest( reqStatus );
       
  2352 		}
       
  2353 	while( KErrNone == reqStatus.Int() );
       
  2354 	}
       
  2355 
       
  2356 		
       
  2357 /**
       
  2358 * Notify cleanup for RPhone::NotifyCapsChange
       
  2359 */	
       
  2360 void CEtelSessionMgr::CleanupPhoneNotifyCapsChange( 
       
  2361 					RPhone& aPhone )
       
  2362 
       
  2363 	{
       
  2364 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPhoneNotifyCapsChange"));
       
  2365 	TRequestStatus reqStatus;
       
  2366 	RPhone::TCaps caps;
       
  2367 	do 
       
  2368 		{
       
  2369 		aPhone.NotifyCapsChange(reqStatus,caps);
       
  2370 		aPhone.NotifyCapsChangeCancel();
       
  2371 		User::WaitForRequest( reqStatus );
       
  2372 		}
       
  2373 	while( KErrNone == reqStatus.Int() );
       
  2374 	}
       
  2375 
       
  2376 		
       
  2377 /**
       
  2378 * Notify cleanup for RPhone::NotifyModemDetected
       
  2379 */	
       
  2380 void CEtelSessionMgr::CleanupPhoneNotifyModemDetected( 
       
  2381 					RPhone& aPhone )
       
  2382 
       
  2383 	{
       
  2384 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPhoneNotifyModemDetected"));
       
  2385 	TRequestStatus reqStatus;
       
  2386 	RPhone::TModemDetection detection;
       
  2387 	do 
       
  2388 		{
       
  2389 		aPhone.NotifyModemDetected(reqStatus,detection);
       
  2390 		aPhone.NotifyModemDetectedCancel();
       
  2391 		User::WaitForRequest( reqStatus );
       
  2392 		}
       
  2393 	while( KErrNone == reqStatus.Int() );
       
  2394 	}
       
  2395 
       
  2396 		
       
  2397 /**
       
  2398 * Notify cleanup for RMobileLocationServices::NotifyMtlr
       
  2399 */	
       
  2400 void CEtelSessionMgr::CleanupMobileLocationServicesNotifyMtlr( 
       
  2401 					RMobileLocationServices& aMobileLocationServices )
       
  2402 
       
  2403 	{
       
  2404 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileLocationServicesNotifyMtlr"));
       
  2405 	TRequestStatus reqStatus;
       
  2406 	RMobileLocationServices::TNotifyMtlrV7 pkgType;
       
  2407 	RMobileLocationServices::TNotifyMtlrV7Pckg pkgArg(pkgType);
       
  2408 	do 
       
  2409 		{
       
  2410 		aMobileLocationServices.NotifyMtlr(reqStatus,pkgArg);
       
  2411 		aMobileLocationServices.CancelAsyncRequest(EMobileLocationServicesNotifyMtlr);
       
  2412 		User::WaitForRequest( reqStatus );
       
  2413 		}
       
  2414 	while( KErrNone == reqStatus.Int() );
       
  2415 	}
       
  2416 
       
  2417 		
       
  2418 /**
       
  2419 * Notify cleanup for RMobileLocationServices::NotifyMeasurementControl
       
  2420 */	
       
  2421 void CEtelSessionMgr::CleanupMobileLocationServicesNotifyMeasurementControl( 
       
  2422 					RMobileLocationServices& aMobileLocationServices )
       
  2423 
       
  2424 	{
       
  2425 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileLocationServicesNotifyMeasurementControl"));
       
  2426 	TRequestStatus reqStatus;
       
  2427 	RMobileLocationServices::TMeasurementControlV7 pkgType;
       
  2428 	RMobileLocationServices::TMeasurementControlV7Pckg pkgArg(pkgType);
       
  2429 	do 
       
  2430 		{
       
  2431 		aMobileLocationServices.NotifyMeasurementControl(reqStatus,pkgArg);
       
  2432 		aMobileLocationServices.CancelAsyncRequest(EMobileLocationServicesNotifyMeasurementControl);
       
  2433 		User::WaitForRequest( reqStatus );
       
  2434 		}
       
  2435 	while( KErrNone == reqStatus.Int() );
       
  2436 	}
       
  2437 
       
  2438 /**
       
  2439 * Notify cleanup for RMmCustomAPI::NotifyAlsBlockedChanged
       
  2440 */	
       
  2441 void CEtelSessionMgr::CleanupMmCustomAPINotifyAlsBlockedChanged( 
       
  2442 					RMmCustomAPI& aMmCustomAPI )
       
  2443 
       
  2444 	{
       
  2445 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyAlsBlockedChanged"));
       
  2446 	TRequestStatus reqStatus;
       
  2447 	RMmCustomAPI::TGetAlsBlockStatus blockStatus;
       
  2448 	do 
       
  2449 		{
       
  2450 		aMmCustomAPI.NotifyAlsBlockedChanged(reqStatus,blockStatus);
       
  2451 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyAlsBlockedChangedIPC);
       
  2452 		User::WaitForRequest( reqStatus );
       
  2453 		}
       
  2454 	while( KErrNone == reqStatus.Int() );
       
  2455 	}
       
  2456 
       
  2457 		
       
  2458 /**
       
  2459 * Notify cleanup for RMmCustomAPI::NotifyCellInfoChange
       
  2460 */	
       
  2461 void CEtelSessionMgr::CleanupMmCustomAPINotifyCellInfoChange( 
       
  2462 					RMmCustomAPI& aMmCustomAPI )
       
  2463 
       
  2464 	{
       
  2465 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyCellInfoChange"));
       
  2466 	TRequestStatus reqStatus;
       
  2467 	RMmCustomAPI::TMmCellInfo pkgType;
       
  2468 	RMmCustomAPI::TMmCellInfoPckg pkgArg(pkgType);
       
  2469 	do 
       
  2470 		{
       
  2471 		aMmCustomAPI.NotifyCellInfoChange(reqStatus,pkgArg);
       
  2472 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyCellInfoChangeIPC);
       
  2473 		User::WaitForRequest( reqStatus );
       
  2474 		}
       
  2475 	while( KErrNone == reqStatus.Int() );
       
  2476 	}
       
  2477 
       
  2478 		
       
  2479 /**
       
  2480 * Notify cleanup for RMmCustomAPI::NotifyCipheringInfoChange
       
  2481 */	
       
  2482 void CEtelSessionMgr::CleanupMmCustomAPINotifyCipheringInfoChange( 
       
  2483 					RMmCustomAPI& aMmCustomAPI )
       
  2484 
       
  2485 	{
       
  2486 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyCipheringInfoChange"));
       
  2487 	TRequestStatus reqStatus;
       
  2488 	RMmCustomAPI::TCipheringInfo cellInfo;
       
  2489 	do 
       
  2490 		{
       
  2491 		aMmCustomAPI.NotifyCipheringInfoChange(reqStatus,cellInfo);
       
  2492 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyCipheringInfoChangeIPC);
       
  2493 		User::WaitForRequest( reqStatus );
       
  2494 		}
       
  2495 	while( KErrNone == reqStatus.Int() );
       
  2496 	}
       
  2497 
       
  2498 		
       
  2499 /**
       
  2500 * Notify cleanup for RMmCustomAPI::NotifyDtmfEvent
       
  2501 */	
       
  2502 void CEtelSessionMgr::CleanupMmCustomAPINotifyDtmfEvent( 
       
  2503 					RMmCustomAPI& aMmCustomAPI )
       
  2504 
       
  2505 	{
       
  2506 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyDtmfEvent"));
       
  2507 	TRequestStatus reqStatus;
       
  2508 	RMmCustomAPI::TDtmfInfo info;
       
  2509 	do 
       
  2510 		{
       
  2511 		aMmCustomAPI.NotifyDtmfEvent(reqStatus,info);
       
  2512 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyDtmfEventIPC);
       
  2513 		User::WaitForRequest( reqStatus );
       
  2514 		}
       
  2515 	while( KErrNone == reqStatus.Int() );
       
  2516 	}
       
  2517 
       
  2518 		
       
  2519 /**
       
  2520 * Notify cleanup for RMmCustomAPI::NotifyEGprsInfoChange
       
  2521 */	
       
  2522 void CEtelSessionMgr::CleanupMmCustomAPINotifyEGprsInfoChange( 
       
  2523 					RMmCustomAPI& aMmCustomAPI )
       
  2524 
       
  2525 	{
       
  2526 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyEGprsInfoChange"));
       
  2527 	TRequestStatus reqStatus;
       
  2528 	RMmCustomAPI::TGprsInformationType pkgType;
       
  2529 	TPckg<RMmCustomAPI::TGprsInformationType> pkgArg(pkgType);
       
  2530 	do 
       
  2531 		{
       
  2532 		aMmCustomAPI.NotifyEGprsInfoChange(reqStatus,pkgArg);
       
  2533 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyEGprsInfoChange);
       
  2534 		User::WaitForRequest( reqStatus );
       
  2535 		}
       
  2536 	while( KErrNone == reqStatus.Int() );
       
  2537 	}
       
  2538 
       
  2539 		
       
  2540 /**
       
  2541 * Notify cleanup for RMmCustomAPI::NotifyHSxPAStatus
       
  2542 */	
       
  2543 void CEtelSessionMgr::CleanupMmCustomAPINotifyHSxPAStatus( 
       
  2544 					RMmCustomAPI& aMmCustomAPI )
       
  2545 
       
  2546 	{
       
  2547 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyHSxPAStatus"));
       
  2548 	TRequestStatus reqStatus;
       
  2549 	RMmCustomAPI::THSxPAStatus hSxPAStatus;
       
  2550 	do 
       
  2551 		{
       
  2552 		aMmCustomAPI.NotifyHSxPAStatus(reqStatus,hSxPAStatus);
       
  2553 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyHSxPAStatusIPC);
       
  2554 		User::WaitForRequest( reqStatus );
       
  2555 		}
       
  2556 	while( KErrNone == reqStatus.Int() );
       
  2557 	}
       
  2558 
       
  2559 		
       
  2560 /**
       
  2561 * Notify cleanup for RMmCustomAPI::NotifyIccCallForwardingStatusChange
       
  2562 */	
       
  2563 void CEtelSessionMgr::CleanupMmCustomAPINotifyIccCallForwardingStatusChange( 
       
  2564 					RMmCustomAPI& aMmCustomAPI )
       
  2565 
       
  2566 	{
       
  2567 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyIccCallForwardingStatusChange"));
       
  2568 	TRequestStatus reqStatus;
       
  2569 	RMmCustomAPI::TCFIndicators pkgType;
       
  2570 	RMmCustomAPI::TCFIndicatorsPckg pkgArg(pkgType);
       
  2571 	do 
       
  2572 		{
       
  2573 		aMmCustomAPI.NotifyIccCallForwardingStatusChange(reqStatus,pkgArg);
       
  2574 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyIccCallForwardingStatusChangeIPC);
       
  2575 		User::WaitForRequest( reqStatus );
       
  2576 		}
       
  2577 	while( KErrNone == reqStatus.Int() );
       
  2578 	}
       
  2579 
       
  2580 		
       
  2581 /**
       
  2582 * Notify cleanup for RMmCustomAPI::NotifyNetworkConnectionFailure
       
  2583 */	
       
  2584 void CEtelSessionMgr::CleanupMmCustomAPINotifyNetworkConnectionFailure( 
       
  2585 					RMmCustomAPI& aMmCustomAPI )
       
  2586 
       
  2587 	{
       
  2588 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyNetworkConnectionFailure"));
       
  2589 	TRequestStatus reqStatus;
       
  2590 	do 
       
  2591 		{
       
  2592 		aMmCustomAPI.NotifyNetworkConnectionFailure(reqStatus);
       
  2593 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyNetworkConnectionFailureIPC);
       
  2594 		User::WaitForRequest( reqStatus );
       
  2595 		}
       
  2596 	while( KErrNone == reqStatus.Int() );
       
  2597 	}
       
  2598 
       
  2599 		
       
  2600 /**
       
  2601 * Notify cleanup for RMmCustomAPI::NotifyNSPSStatus
       
  2602 */	
       
  2603 void CEtelSessionMgr::CleanupMmCustomAPINotifyNSPSStatus( 
       
  2604 					RMmCustomAPI& aMmCustomAPI )
       
  2605 
       
  2606 	{
       
  2607 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyNSPSStatus"));
       
  2608 	TRequestStatus reqStatus;
       
  2609 	RMmCustomAPI::TNspsStatus nspsStatus;
       
  2610 	do 
       
  2611 		{
       
  2612 		aMmCustomAPI.NotifyNSPSStatus(reqStatus,nspsStatus);
       
  2613 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyNSPSStatusIPC);
       
  2614 		User::WaitForRequest( reqStatus );
       
  2615 		}
       
  2616 	while( KErrNone == reqStatus.Int() );
       
  2617 	}
       
  2618 
       
  2619 		
       
  2620 /**
       
  2621 * Notify cleanup for RMmCustomAPI::NotifyPndCacheReady
       
  2622 */	
       
  2623 void CEtelSessionMgr::CleanupMmCustomAPINotifyPndCacheReady( 
       
  2624 					RMmCustomAPI& aMmCustomAPI )
       
  2625 
       
  2626 	{
       
  2627 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyPndCacheReady"));
       
  2628 	TRequestStatus reqStatus;
       
  2629 	TName pndName;
       
  2630 	do 
       
  2631 		{
       
  2632 		aMmCustomAPI.NotifyPndCacheReady(reqStatus,pndName);
       
  2633 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyPndCacheReadyIPC);
       
  2634 		User::WaitForRequest( reqStatus );
       
  2635 		}
       
  2636 	while( KErrNone == reqStatus.Int() );
       
  2637 	}
       
  2638 
       
  2639 		
       
  2640 /**
       
  2641 * Notify cleanup for RMmCustomAPI::NotifyProgrammableOperatorLogoChange
       
  2642 */	
       
  2643 void CEtelSessionMgr::CleanupMmCustomAPINotifyProgrammableOperatorLogoChange( 
       
  2644 					RMmCustomAPI& aMmCustomAPI )
       
  2645 
       
  2646 	{
       
  2647 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyProgrammableOperatorLogoChange"));
       
  2648 	TRequestStatus reqStatus;
       
  2649 	RMmCustomAPI::TOperatorId operatorId;
       
  2650 	do 
       
  2651 		{
       
  2652 		aMmCustomAPI.NotifyProgrammableOperatorLogoChange(reqStatus,operatorId);
       
  2653 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyProgrammableOperatorLogoChangeIPC);
       
  2654 		User::WaitForRequest( reqStatus );
       
  2655 		}
       
  2656 	while( KErrNone == reqStatus.Int() );
       
  2657 	}
       
  2658 
       
  2659 		
       
  2660 /**
       
  2661 * Notify cleanup for RMmCustomAPI::NotifyRauEvent
       
  2662 */	
       
  2663 void CEtelSessionMgr::CleanupMmCustomAPINotifyRauEvent( 
       
  2664 					RMmCustomAPI& aMmCustomAPI )
       
  2665 
       
  2666 	{
       
  2667 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifyRauEvent"));
       
  2668 	TRequestStatus reqStatus;
       
  2669 	RMmCustomAPI::TRauEventStatus eventStatus;
       
  2670 	do 
       
  2671 		{
       
  2672 		aMmCustomAPI.NotifyRauEvent(reqStatus,eventStatus);
       
  2673 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifyRauEventIPC);
       
  2674 		User::WaitForRequest( reqStatus );
       
  2675 		}
       
  2676 	while( KErrNone == reqStatus.Int() );
       
  2677 	}
       
  2678 
       
  2679 		
       
  2680 /**
       
  2681 * Notify cleanup for RMmCustomAPI::NotifySimCardStatus
       
  2682 */	
       
  2683 void CEtelSessionMgr::CleanupMmCustomAPINotifySimCardStatus( 
       
  2684 					RMmCustomAPI& aMmCustomAPI )
       
  2685 
       
  2686 	{
       
  2687 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifySimCardStatus"));
       
  2688 	TRequestStatus reqStatus;
       
  2689 	RMmCustomAPI::TSIMCardStatus cardStatus;
       
  2690 	do 
       
  2691 		{
       
  2692 		aMmCustomAPI.NotifySimCardStatus(reqStatus,cardStatus);
       
  2693 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifySimCardStatusIPC);
       
  2694 		User::WaitForRequest( reqStatus );
       
  2695 		}
       
  2696 	while( KErrNone == reqStatus.Int() );
       
  2697 	}
       
  2698 
       
  2699 		
       
  2700 /**
       
  2701 * Notify cleanup for RMmCustomAPI::NotifySsNetworkEvent
       
  2702 */	
       
  2703 void CEtelSessionMgr::CleanupMmCustomAPINotifySsNetworkEvent( 
       
  2704 					RMmCustomAPI& aMmCustomAPI )
       
  2705 
       
  2706 	{
       
  2707 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifySsNetworkEvent"));
       
  2708 	TRequestStatus reqStatus;
       
  2709 	RMmCustomAPI::TSsTypeAndMode ssTypeAndMode;
       
  2710 	RMmCustomAPI::TSsInfo ssInfo;
       
  2711 	do 
       
  2712 		{
       
  2713 		aMmCustomAPI.NotifySsNetworkEvent(reqStatus,ssTypeAndMode,ssInfo);
       
  2714 		aMmCustomAPI.CancelAsyncRequest(ECustomNotifySsNetworkEventIPC);
       
  2715 		User::WaitForRequest( reqStatus );
       
  2716 		}
       
  2717 	while( KErrNone == reqStatus.Int() );
       
  2718 	}
       
  2719 
       
  2720 //
       
  2721 //Session Cleanups 
       
  2722 //
       
  2723 /**
       
  2724 * Cleanup notifiers for RMobileBroadcastMessaging
       
  2725 */	
       
  2726 void CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifiers( 
       
  2727 					RMobileBroadcastMessaging& aMobileBroadcastMessaging )
       
  2728 
       
  2729 	{
       
  2730 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileBroadcastMessagingNotifiers"));
       
  2731 	CleanupMobileBroadcastMessagingNotifyBroadcastIdListChange( aMobileBroadcastMessaging );
       
  2732 	CleanupMobileBroadcastMessagingNotifyFilterSettingChange( aMobileBroadcastMessaging );
       
  2733 	CleanupMobileBroadcastMessagingNotifyLanguageFilterChange( aMobileBroadcastMessaging );
       
  2734 
       
  2735 	}
       
  2736 /**
       
  2737 * Cleanup notifiers for RMobileLine
       
  2738 */	
       
  2739 void CEtelSessionMgr::CleanupMobileLineNotifiers( 
       
  2740 					RMobileLine& aMobileLine )
       
  2741 
       
  2742 	{
       
  2743 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileLineNotifiers"));
       
  2744 	CleanupMobileLineNotifyMobileLineStatusChange( aMobileLine );
       
  2745 
       
  2746 	}
       
  2747 /**
       
  2748 * Cleanup notifiers for RMobilePhone
       
  2749 */	
       
  2750 void CEtelSessionMgr::CleanupMobilePhoneNotifiers( 
       
  2751 					RMobilePhone& aMobilePhone )
       
  2752 
       
  2753 	{
       
  2754 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneNotifiers"));
       
  2755 	CleanupMobilePhoneNotifyALSLineChange( aMobilePhone );
       
  2756 	CleanupMobilePhoneNotifyAlternatingCallCapsChange( aMobilePhone );
       
  2757 	CleanupMobilePhoneNotifyAlternatingCallModeChange( aMobilePhone );
       
  2758 	CleanupMobilePhoneNotifyCCBSRecall( aMobilePhone );
       
  2759 	CleanupMobilePhoneNotifyCCBSRecall1( aMobilePhone );
       
  2760 	CleanupMobilePhoneNotifyCCBSStatusChange( aMobilePhone );
       
  2761 	CleanupMobilePhoneNotifyCallBarringStatusChange( aMobilePhone );
       
  2762 	CleanupMobilePhoneNotifyCallForwardingActive( aMobilePhone );
       
  2763 	CleanupMobilePhoneNotifyCallForwardingStatusChange( aMobilePhone );
       
  2764 	CleanupMobilePhoneNotifyCallServiceCapsChange( aMobilePhone );
       
  2765 	CleanupMobilePhoneNotifyCallWaitingStatusChange( aMobilePhone );
       
  2766 	CleanupMobilePhoneNotifyCipheringIndicatorStatus( aMobilePhone );
       
  2767 	CleanupMobilePhoneNotifyCostCapsChange( aMobilePhone );
       
  2768 	CleanupMobilePhoneNotifyDTMFCapsChange( aMobilePhone );
       
  2769 	CleanupMobilePhoneNotifyDTMFEvent( aMobilePhone );
       
  2770 	CleanupMobilePhoneNotifyFdnStatusChange( aMobilePhone );
       
  2771 	CleanupMobilePhoneNotifyIccAccessCapsChange( aMobilePhone );
       
  2772 	CleanupMobilePhoneNotifyIdentityServiceStatus( aMobilePhone );
       
  2773 	CleanupMobilePhoneNotifyIdentitySuppressionRejected( aMobilePhone );
       
  2774 	CleanupMobilePhoneNotifyIncomingCallTypeChange( aMobilePhone );
       
  2775 	CleanupMobilePhoneNotifyIndicatorChange( aMobilePhone );
       
  2776 	CleanupMobilePhoneNotifyMessageWaiting( aMobilePhone );
       
  2777 	CleanupMobilePhoneNotifyModeChange( aMobilePhone );
       
  2778 	CleanupMobilePhoneNotifyMulticallIndicatorChange( aMobilePhone );
       
  2779 	CleanupMobilePhoneNotifyMulticallParamsChange( aMobilePhone );
       
  2780 	CleanupMobilePhoneNotifyMultimediaCallPreferenceChange( aMobilePhone );
       
  2781 	CleanupMobilePhoneNotifyNetworkInvScanChange( aMobilePhone );
       
  2782 	CleanupMobilePhoneNotifyNetworkInvScanEvent( aMobilePhone );
       
  2783 	CleanupMobilePhoneNotifyNetworkRegistrationStatusChange( aMobilePhone );
       
  2784 	CleanupMobilePhoneNotifyNetworkSecurityLevelChange( aMobilePhone );
       
  2785 	CleanupMobilePhoneNotifySecurityCapsChange( aMobilePhone );
       
  2786 	CleanupMobilePhoneNotifySecurityEvent( aMobilePhone );
       
  2787 	CleanupMobilePhoneNotifySendNetworkServiceRequest( aMobilePhone );
       
  2788 	CleanupMobilePhoneNotifySignalStrengthChange( aMobilePhone );
       
  2789 	CleanupMobilePhoneNotifyPreferredNetworksListChange( aMobilePhone );
       
  2790 	CleanupMobilePhoneNotifyStopInDTMFString( aMobilePhone );
       
  2791 	CleanupMobilePhoneNotifyAirTimeDurationChange( aMobilePhone );
       
  2792 	CleanupMobilePhoneNotifyCostInfoChange( aMobilePhone );
       
  2793 	CleanupMobilePhoneNotifyCurrentNetworkChange( aMobilePhone );
       
  2794 	CleanupMobilePhoneNotifyCurrentNetworkChange5( aMobilePhone );
       
  2795 	CleanupMobilePhoneNotifyCurrentNetworkChange1( aMobilePhone );
       
  2796 	CleanupMobilePhoneNotifyCurrentNetworkChange2( aMobilePhone );
       
  2797 	CleanupMobilePhoneNotifyCurrentNetworkChange3( aMobilePhone );
       
  2798 	CleanupMobilePhoneNotifyCurrentNetworkChange4( aMobilePhone );
       
  2799 	CleanupMobilePhoneNotifyLockInfoChange( aMobilePhone );
       
  2800 	CleanupMobilePhoneNotifyNITZInfoChange( aMobilePhone );
       
  2801 	CleanupMobilePhoneNotifyNetworkSelectionSettingChange( aMobilePhone );
       
  2802 	CleanupMobilePhoneNotifySecurityCodeInfoChange( aMobilePhone );
       
  2803 	CleanupMobilePhoneNotifyUSimApplicationsInfoChange( aMobilePhone );
       
  2804 	CleanupMobilePhoneNotifyUSimAppsSelectionModeChange( aMobilePhone );
       
  2805 	CleanupMobilePhoneNotifyUUSSettingChange( aMobilePhone );
       
  2806 	CleanupMobilePhoneNotifyIccMessageWaitingIndicatorsChange( aMobilePhone );
       
  2807 	CleanupMobilePhoneNotifyMmsConfig( aMobilePhone );
       
  2808 	CleanupMobilePhoneNotifyMmsUpdate( aMobilePhone );
       
  2809 	CleanupMobilePhoneNotifyBatteryInfoChange( aMobilePhone );
       
  2810 	CleanupMobilePhoneNotifyImsAuthorizationInfoChange( aMobilePhone );
       
  2811 	CleanupMobilePhoneNotifySmartCardApplicationInfoChange( aMobilePhone );
       
  2812 	CleanupMobilePhoneNotifyDefaultPrivacyChange( aMobilePhone );
       
  2813 	CleanupMobilePhoneNotifyAPNListChanged( aMobilePhone );
       
  2814 	CleanupMobilePhoneNotifyAPNControlListServiceStatusChange( aMobilePhone );
       
  2815 	CleanupMobilePhoneNotifyMailboxNumbersChange( aMobilePhone );
       
  2816 
       
  2817 	}
       
  2818 /**
       
  2819 * Cleanup notifiers for RPacketQoS
       
  2820 */	
       
  2821 void CEtelSessionMgr::CleanupPacketQoSNotifiers( 
       
  2822 					RPacketQoS& aPacketQoS )
       
  2823 
       
  2824 	{
       
  2825 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketQoSNotifiers"));
       
  2826 	CleanupPacketQoSNotifyProfileChanged( aPacketQoS );
       
  2827 	CleanupPacketQoSNotifyProfileChanged1( aPacketQoS );
       
  2828 	CleanupPacketQoSNotifyProfileChanged2( aPacketQoS );
       
  2829 
       
  2830 	}
       
  2831 /**
       
  2832 * Cleanup notifiers for RMobileSmartCardEap
       
  2833 */	
       
  2834 void CEtelSessionMgr::CleanupMobileSmartCardEapNotifiers( 
       
  2835 					RMobileSmartCardEap& aMobileSmartCardEap )
       
  2836 
       
  2837 	{
       
  2838 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmartCardEapNotifiers"));
       
  2839 	CleanupMobileSmartCardEapNotifyEapMethodAccessStatusChange( aMobileSmartCardEap );
       
  2840 
       
  2841 	}
       
  2842 /**
       
  2843 * Cleanup notifiers for RMobileSmsMessaging
       
  2844 */	
       
  2845 void CEtelSessionMgr::CleanupMobileSmsMessagingNotifiers( 
       
  2846 					RMobileSmsMessaging& aMobileSmsMessaging )
       
  2847 
       
  2848 	{
       
  2849 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileSmsMessagingNotifiers"));
       
  2850 	CleanupMobileSmsMessagingNotifyMoSmsBearerChange( aMobileSmsMessaging );
       
  2851 	CleanupMobileSmsMessagingNotifyReceiveModeChange( aMobileSmsMessaging );
       
  2852 	CleanupMobileSmsMessagingNotifySmspListChange( aMobileSmsMessaging );
       
  2853 
       
  2854 	}
       
  2855 /**
       
  2856 * Cleanup notifiers for RMobileCall
       
  2857 */	
       
  2858 void CEtelSessionMgr::CleanupMobileCallNotifiers( 
       
  2859 					RMobileCall& aMobileCall )
       
  2860 
       
  2861 	{
       
  2862 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileCallNotifiers"));
       
  2863 	CleanupMobileCallNotifyAlternatingCallSwitch( aMobileCall );
       
  2864 	CleanupMobileCallNotifyAudioToneEvent( aMobileCall );
       
  2865 	CleanupMobileCallNotifyCallEvent( aMobileCall );
       
  2866 	CleanupMobileCallNotifyHscsdInfoChange( aMobileCall );
       
  2867 	CleanupMobileCallNotifyMobileCallCapsChange( aMobileCall );
       
  2868 	CleanupMobileCallNotifyMobileCallStatusChange( aMobileCall );
       
  2869 	CleanupMobileCallNotifyMobileDataCallCapsChange( aMobileCall );
       
  2870 	CleanupMobileCallNotifyUUSCapsChange( aMobileCall );
       
  2871 	CleanupMobileCallNotifyVoiceFallback( aMobileCall );
       
  2872 	CleanupMobileCallNotifyPrivacyConfirmation( aMobileCall );
       
  2873 	CleanupMobileCallNotifyTrafficChannelConfirmation( aMobileCall );
       
  2874 	CleanupMobileCallNotifyRemotePartyInfoChange( aMobileCall );
       
  2875 
       
  2876 	}
       
  2877 /**
       
  2878 * Cleanup notifiers for RLine
       
  2879 */	
       
  2880 void CEtelSessionMgr::CleanupLineNotifiers( 
       
  2881 					RLine& aLine )
       
  2882 
       
  2883 	{
       
  2884 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupLineNotifiers"));
       
  2885 	CleanupLineNotifyCapsChange( aLine );
       
  2886 	CleanupLineNotifyCallAdded( aLine );
       
  2887 	CleanupLineNotifyHookChange( aLine );
       
  2888 	CleanupLineNotifyStatusChange( aLine );
       
  2889 	CleanupLineNotifyIncomingCall( aLine );
       
  2890 
       
  2891 	}
       
  2892 /**
       
  2893 * Cleanup notifiers for RMobilePhoneStore
       
  2894 */	
       
  2895 void CEtelSessionMgr::CleanupMobilePhoneStoreNotifiers( 
       
  2896 					RMobilePhoneStore& aMobilePhoneStore )
       
  2897 
       
  2898 	{
       
  2899 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobilePhoneStoreNotifiers"));
       
  2900 	CleanupMobilePhoneStoreNotifyStoreEvent( aMobilePhoneStore );
       
  2901 
       
  2902 	}
       
  2903 /**
       
  2904 * Cleanup notifiers for RMobileConferenceCall
       
  2905 */	
       
  2906 void CEtelSessionMgr::CleanupMobileConferenceCallNotifiers( 
       
  2907 					RMobileConferenceCall& aMobileConferenceCall )
       
  2908 
       
  2909 	{
       
  2910 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileConferenceCallNotifiers"));
       
  2911 	CleanupMobileConferenceCallNotifyCapsChange( aMobileConferenceCall );
       
  2912 	CleanupMobileConferenceCallNotifyConferenceEvent( aMobileConferenceCall );
       
  2913 	CleanupMobileConferenceCallNotifyConferenceStatusChange( aMobileConferenceCall );
       
  2914 
       
  2915 	}
       
  2916 /**
       
  2917 * Cleanup notifiers for RPacketContext
       
  2918 */	
       
  2919 void CEtelSessionMgr::CleanupPacketContextNotifiers( 
       
  2920 					RPacketContext& aPacketContext )
       
  2921 
       
  2922 	{
       
  2923 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketContextNotifiers"));
       
  2924 	CleanupPacketContextNotifyConnectionSpeedChange( aPacketContext );
       
  2925 	CleanupPacketContextNotifyStatusChange( aPacketContext );
       
  2926 	CleanupPacketContextNotifyConfigChanged( aPacketContext );
       
  2927 	CleanupPacketContextNotifyConfigChanged1( aPacketContext );
       
  2928 	CleanupPacketContextNotifyConfigChanged2( aPacketContext );
       
  2929 	CleanupPacketContextNotifyDataTransferred( aPacketContext );
       
  2930 
       
  2931 	}
       
  2932 /**
       
  2933 * Cleanup notifiers for RMobileUssdMessaging
       
  2934 */	
       
  2935 void CEtelSessionMgr::CleanupMobileUssdMessagingNotifiers( 
       
  2936 					RMobileUssdMessaging& aMobileUssdMessaging )
       
  2937 
       
  2938 	{
       
  2939 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileUssdMessagingNotifiers"));
       
  2940 	CleanupMobileUssdMessagingNotifyNetworkRelease( aMobileUssdMessaging );
       
  2941 
       
  2942 	}
       
  2943 /**
       
  2944 * Cleanup notifiers for RPacketService
       
  2945 */	
       
  2946 void CEtelSessionMgr::CleanupPacketServiceNotifiers( 
       
  2947 					RPacketService& aPacketService )
       
  2948 
       
  2949 	{
       
  2950 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketServiceNotifiers"));
       
  2951 	CleanupPacketServiceNotifyAttachModeChange( aPacketService );
       
  2952 	CleanupPacketServiceNotifyChangeOfNtwkRegStatus( aPacketService );
       
  2953 	CleanupPacketServiceNotifyContextActivationRequested( aPacketService );
       
  2954 	CleanupPacketServiceNotifyContextActivationRequested1( aPacketService );
       
  2955 	CleanupPacketServiceNotifyContextActivationRequested2( aPacketService );
       
  2956 	CleanupPacketServiceNotifyContextAdded( aPacketService );
       
  2957 	CleanupPacketServiceNotifyDynamicCapsChange( aPacketService );
       
  2958 	CleanupPacketServiceNotifyMSClassChange( aPacketService );
       
  2959 	CleanupPacketServiceNotifyReleaseModeChange( aPacketService );
       
  2960 	CleanupPacketServiceNotifyStatusChange( aPacketService );
       
  2961 
       
  2962 	}
       
  2963 /**
       
  2964 * Cleanup notifiers for RCall
       
  2965 */	
       
  2966 void CEtelSessionMgr::CleanupCallNotifiers( 
       
  2967 					RCall& aCall )
       
  2968 
       
  2969 	{
       
  2970 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupCallNotifiers"));
       
  2971 	CleanupCallNotifyCapsChange( aCall );
       
  2972 	CleanupCallNotifyCallDurationChange( aCall );
       
  2973 	CleanupCallNotifyHookChange( aCall );
       
  2974 	CleanupCallNotifyStatusChange( aCall );
       
  2975 
       
  2976 	}
       
  2977 /**
       
  2978 * Cleanup notifiers for RPhone
       
  2979 */	
       
  2980 void CEtelSessionMgr::CleanupPhoneNotifiers( 
       
  2981 					RPhone& aPhone )
       
  2982 
       
  2983 	{
       
  2984 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPhoneNotifiers"));
       
  2985 	CleanupPhoneNotifyCapsChange( aPhone );
       
  2986 	CleanupPhoneNotifyModemDetected( aPhone );
       
  2987 
       
  2988 	}
       
  2989 /**
       
  2990 * Cleanup notifiers for RMobileLocationServices
       
  2991 */	
       
  2992 void CEtelSessionMgr::CleanupMobileLocationServicesNotifiers( 
       
  2993 					RMobileLocationServices& aMobileLocationServices )
       
  2994 
       
  2995 	{
       
  2996 	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMobileLocationServicesNotifiers"));
       
  2997 	CleanupMobileLocationServicesNotifyMtlr( aMobileLocationServices );
       
  2998 	CleanupMobileLocationServicesNotifyMeasurementControl( aMobileLocationServices );
       
  2999 
       
  3000 	}
       
  3001 
       
  3002 /**
       
  3003 * Cleanup notifiers for RMmCustomAPI
       
  3004 */	
       
  3005 void CEtelSessionMgr::CleanupCustomAPINotifiers( 
       
  3006 					RMmCustomAPI& aMmCustomAPI )
       
  3007 
       
  3008 	{
       
  3009     TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupMmCustomAPINotifiers"));
       
  3010 	CleanupMmCustomAPINotifyAlsBlockedChanged( aMmCustomAPI );
       
  3011 	CleanupMmCustomAPINotifyCellInfoChange( aMmCustomAPI );
       
  3012 	CleanupMmCustomAPINotifyCipheringInfoChange( aMmCustomAPI );
       
  3013 	CleanupMmCustomAPINotifyDtmfEvent( aMmCustomAPI );
       
  3014 	CleanupMmCustomAPINotifyEGprsInfoChange( aMmCustomAPI );
       
  3015 	CleanupMmCustomAPINotifyHSxPAStatus( aMmCustomAPI );
       
  3016 	CleanupMmCustomAPINotifyIccCallForwardingStatusChange( aMmCustomAPI );
       
  3017 	CleanupMmCustomAPINotifyNetworkConnectionFailure( aMmCustomAPI );
       
  3018 	CleanupMmCustomAPINotifyNSPSStatus( aMmCustomAPI );
       
  3019 	CleanupMmCustomAPINotifyPndCacheReady( aMmCustomAPI );
       
  3020 	CleanupMmCustomAPINotifyProgrammableOperatorLogoChange( aMmCustomAPI );
       
  3021 	CleanupMmCustomAPINotifyRauEvent( aMmCustomAPI );
       
  3022 	CleanupMmCustomAPINotifySimCardStatus( aMmCustomAPI );
       
  3023 	CleanupMmCustomAPINotifySsNetworkEvent( aMmCustomAPI );
       
  3024 
       
  3025 	}
       
  3026