Mercurial Mercurial > oss > FCL > sf > os > cellularsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
telephonyprotocols/pdplayer/umts/spudtel/src/eteldriverstrategies.cpp
branchRCL_3
changeset 65 630d2f34d719
parent 29 cca59d85ca31
child 66 07a122eea281
equal deleted inserted replaced
61:17af172ffa5f 65:630d2f34d719 
    18 /**
 
    18 /**
 
    19  @file 
    19  @file 
    20  @internalComponent
 
    20  @internalComponent
 
    21 */
 
    21 */
 
    22 
    22 
       
    23 
       
    24 
       
    25 #include "OstTraceDefinitions.h"
 
       
    26 #ifdef OST_TRACE_COMPILER_IN_USE
 
       
    27 #include "eteldriverstrategiesTraces.h"
 
       
    28 #endif
 
       
    29 
    23 #include <e32def.h>
 
    30 #include <e32def.h>
 
    24 
    31 
    25 #include "ceteldrivercontext.h"
 
    32 #include "ceteldrivercontext.h"
 
    26 #include "eteldriverstrategies.h"
 
    33 #include "eteldriverstrategies.h"
 
    27 #include "spudteldebuglogger.h"
 
       
    28 #include "pdpfsmnmspace.h"
 
    34 #include "pdpfsmnmspace.h"
 
    29 
    35 
    30 #include <pcktcs.h>
 
    36 #include <pcktcs.h>
 
    31 using namespace ConnectionServ;
 
    37 using namespace ConnectionServ;
 
    32 
    38 
    38 @param aContext - pdp context
 
    44 @param aContext - pdp context
 
    39 @param aStatus - request status of this step
 
    45 @param aStatus - request status of this step
 
    40 */
 
    46 */
 
    41 void TOpenStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
    47 void TOpenStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
    42 	{
 
    48 	{
 
    43 	SPUDTEL_FNLOG("TOpenStrategy::Next()");
 
    49 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_NEXT_1, "TOpenStrategy::Next()");
 
    44 	
    50 	
    45 	TInt err = KErrNone;
 
    51 	TInt err = KErrNone;
 
    46 	
    52 	
    47 	switch(aContext.StrategyStep())
 
    53 	switch(aContext.StrategyStep())
 
    48 		{
 
    54 		{
 
    59 			break;
 
    65 			break;
 
    60 			}
 
    66 			}
 
    61 			
    67 			
    62 		default:
 
    68 		default:
 
    63 			// incorrect step
 
    69 			// incorrect step
 
    64 			SPUDTEL_ERROR_LOG0(_L("Incorrect step"));
 
    70 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_NEXT_2, "Incorrect step");
 
    65 			ASSERT(EFalse);
 
    71 			ASSERT(EFalse);
 
    66 			err = KErrNotSupported;
 
    72 			err = KErrNotSupported;
 
    67 			break;
 
    73 			break;
 
    68 				
    74 				
    69 		} // switch
 
    75 		} // switch
 
    83 */	
    89 */	
    84 void TOpenStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
    90 void TOpenStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
    85 	{
 
    91 	{
 
    86 	if(aCompletionStatus == KErrNone)
 
    92 	if(aCompletionStatus == KErrNone)
 
    87 		{
 
    93 		{
 
    88 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPhoneOpened"));
 
    94 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_NOTIFYFSM_1, "Notifying FSM: EPhoneOpened");
 
    89 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpened);
 
    95 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpened);
 
    90 		}
 
    96 		}
 
    91 	else
 
    97 	else
 
    92 		{
 
    98 		{
 
    93 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPhoneOpenedFailed"));
 
    99 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_NOTIFYFSM_2, "Notifying FSM: EPhoneOpenedFailed");
 
    94 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpenedFailed, aCompletionStatus.Int());
 
   100 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpenedFailed, aCompletionStatus.Int());
 
    95 		}
 
   101 		}
 
    96 	}
 
   102 	}
 
    97 
   103 
    98 /** Cancels last asynchronous request to eTel
 
   104 /** Cancels last asynchronous request to eTel
 
   103 	{
 
   109 	{
 
   104 	switch(aContext.StrategyStep())
 
   110 	switch(aContext.StrategyStep())
 
   105 		{
 
   111 		{
 
   106 		case EInitPhoneStep:
 
   112 		case EInitPhoneStep:
 
   107 			{
 
   113 			{
 
   108 			SPUDTEL_INFO_LOG(_L("Cancel Phone::InitialiseCancel"));
 
   114 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_CANCELASYNCREQUEST_1, "Cancel Phone::InitialiseCancel");
 
   109 			aContext.Phone().InitialiseCancel();
 
   115 			aContext.Phone().InitialiseCancel();
 
   110 			break;
 
   116 			break;
 
   111 			}
 
   117 			}
 
   112 			
   118 			
   113 		default:
 
   119 		default:
 
   114 			// there're NO outstanding async requests
 
   120 			// there're NO outstanding async requests
 
   115 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TOpenStrategy::CancelAsyncRequest"));
 
   121 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TOPENSTRATEGY_CANCELASYNCREQUEST_2, "ERROR: Incorrect case in TOpenStrategy::CancelAsyncRequest");
 
   116 			ASSERT(EFalse);
 
   122 			ASSERT(EFalse);
 
   117 			break;
 
   123 			break;
 
   118 		}
 
   124 		}
 
   119 	}
 
   125 	}
 
   120 
   126 
   127 @param aContext - pdp context
 
   133 @param aContext - pdp context
 
   128 @param aStatus - request status of this step
 
   134 @param aStatus - request status of this step
 
   129 */
 
   135 */
 
   130 void TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   136 void TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   131 	{
 
   137 	{
 
   132 	SPUDTEL_FNLOG("TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)");
 
   138 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_NEXT_1, "TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)");
 
   133 	
   139 	
   134 	TInt err = KErrNone;
 
   140 	TInt err = KErrNone;
 
   135 	
   141 	
   136 	// steps:
 
   142 	// steps:
 
   137 	//	-- cancel notifications
 
   143 	//	-- cancel notifications
 
   233 			break;
 
   239 			break;
 
   234 			}
 
   240 			}
 
   235 			
   241 			
   236 		default:
 
   242 		default:
 
   237 			// incorrect step
 
   243 			// incorrect step
 
   238 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   244 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
   239 			ASSERT(EFalse);
 
   245 			ASSERT(EFalse);
 
   240 			err = KErrNotSupported;
 
   246 			err = KErrNotSupported;
 
   241 			break;
 
   247 			break;
 
   242 				
   248 				
   243 		} // switch
 
   249 		} // switch
 
   260 	{
 
   266 	{
 
   261 	aContext.PdpFsmInterface().Set(aContext.Id(), RPacketContext::EStatusDeleted);
 
   267 	aContext.PdpFsmInterface().Set(aContext.Id(), RPacketContext::EStatusDeleted);
 
   262 	
   268 	
   263 	if(aCompletionStatus == KErrNone)
 
   269 	if(aCompletionStatus == KErrNone)
 
   264 		{
 
   270 		{
 
   265 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EContextDeleted"));
 
   271 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_NOTIFYFSM_1, "Notifying FSM: EContextDeleted");
 
   266 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeleted);
 
   272 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeleted);
 
   267 		}
 
   273 		}
 
   268 	else
 
   274 	else
 
   269 		{
 
   275 		{
 
   270 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EContextDeletedFailed"));
 
   276 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_NOTIFYFSM_2, "Notifying FSM: EContextDeletedFailed");
 
   271 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeletedFailed, aCompletionStatus.Int());
 
   277 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeletedFailed, aCompletionStatus.Int());
 
   272 		}
 
   278 		}
 
   273 	}
 
   279 	}
 
   274 
   280 
   275 /** Cancels last asynchronous request to eTel
 
   281 /** Cancels last asynchronous request to eTel
 
   276 
   282 
   277 @param  aContext - pdp context
 
   283 @param  aContext - pdp context
 
   278 */
 
   284 */
 
   279 void TContextDeleteStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
   285 void TContextDeleteStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
   280 	{
 
   286 	{
 
   281 	SPUDTEL_FNLOG("TContextDeleteStrategy::CancelAsyncRequest()");
 
   287 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_CANCELASYNCREQUEST_1, "TContextDeleteStrategy::CancelAsyncRequest()");
 
   282 	
   288 	
   283 	// When there is no sub-session, the strategy will not call DeactivateContext, but will be in the EDeactivateStep state
 
   289 	// When there is no sub-session, the strategy will not call DeactivateContext, but will be in the EDeactivateStep state
 
   284 	// In this case we don't want to cancel the deactivate request
 
   290 	// In this case we don't want to cancel the deactivate request
 
   285 	if (aContext.iStatus != KRequestPending)
 
   291 	if (aContext.iStatus != KRequestPending)
 
   286 		{
 
   292 		{
 
   289 		
   295 		
   290 	switch(aContext.StrategyStep())
 
   296 	switch(aContext.StrategyStep())
 
   291 		{
 
   297 		{
 
   292 		case EDeactivateStep:
 
   298 		case EDeactivateStep:
 
   293 			{
 
   299 			{
 
   294 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextDeactivate"));
 
   300 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketContext::EPacketContextDeactivate");
 
   295 			aContext.PacketContext().CancelAsyncRequest(EPacketContextDeactivate);
 
   301 			aContext.PacketContext().CancelAsyncRequest(EPacketContextDeactivate);
 
   296 			break;
 
   302 			break;
 
   297 			}
 
   303 			}
 
   298 			
   304 			
   299 		case EDeleteContextStep:
 
   305 		case EDeleteContextStep:
 
   300 			{
 
   306 			{
 
   301 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextDelete"));
 
   307 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_CANCELASYNCREQUEST_3, "Cancel PacketContext::EPacketContextDelete");
 
   302 			aContext.PacketContext().CancelAsyncRequest(EPacketContextDelete);
 
   308 			aContext.PacketContext().CancelAsyncRequest(EPacketContextDelete);
 
   303 			break;
 
   309 			break;
 
   304 			}
 
   310 			}
 
   305 			
   311 			
   306 		default:
 
   312 		default:
 
   307 			// there're NO outstanding async requests
 
   313 			// there're NO outstanding async requests
 
   308 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   314 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCONTEXTDELETESTRATEGY_CANCELASYNCREQUEST_4, "ERROR: Incorrect case");
 
   309 			ASSERT(EFalse);
 
   315 			ASSERT(EFalse);
 
   310 			break;
 
   316 			break;
 
   311 		}
 
   317 		}
 
   312 	}
 
   318 	}
 
   313 
   319 
   320 @param aContext - pdp context
 
   326 @param aContext - pdp context
 
   321 @param aStatus - request status of this step
 
   327 @param aStatus - request status of this step
 
   322 */
 
   328 */
 
   323 void TCreate1ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   329 void TCreate1ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   324 	{
 
   330 	{
 
   325 	SPUDTEL_FNLOG("TCreate1ryPdpContextStrategy::Next()");
 
   331 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NEXT_1, "TCreate1ryPdpContextStrategy::Next()");
 
   326 	
   332 	
   327 	TInt err = KErrNone;
 
   333 	TInt err = KErrNone;
 
   328 	
   334 	
   329 	// possible steps:
 
   335 	// possible steps:
 
   330 	// 	-- open new context
 
   336 	// 	-- open new context
 
   335 		case EStartStep:
 
   341 		case EStartStep:
 
   336 			{
 
   342 			{
 
   337 			err = aContext.PacketContext().OpenNewContext (aContext.PacketService(), aContext.Name());
 
   343 			err = aContext.PacketContext().OpenNewContext (aContext.PacketService(), aContext.Name());
 
   338 			if (err)
 
   344 			if (err)
 
   339 				{
 
   345 				{
 
   340 				SPUDTEL_ERROR_LOG(_L("PacketContextOpenNewContext returned %d"), err);
 
   346 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NEXT_2, "PacketContextOpenNewContext returned %d", err);
 
   341 				break;
 
   347 				break;
 
   342 				}
 
   348 				}
 
   343 				
   349 				
   344 			aContext.PacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						
   350 			aContext.PacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						
   345 			aContext.SetStrategyStep (EInitialiseContextStep);
 
   351 			aContext.SetStrategyStep (EInitialiseContextStep);
 
   362 			// QoS name is not used anywhere
 
   368 			// QoS name is not used anywhere
 
   363 			TName newName;
 
   369 			TName newName;
 
   364 			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);
 
   370 			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);
 
   365 			if (err)
 
   371 			if (err)
 
   366 				{ 
   372 				{ 
   367 				SPUDTEL_ERROR_LOG(_L("PacketQoS OpenNewQoS returned %d"), err);
 
   373 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NEXT_3, "PacketQoS OpenNewQoS returned %d", err);
 
   368 				break; 
   374 				break; 
   369 				}
 
   375 				}
 
   370 				
   376 				
   371 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
   377 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
   372             RPacketQoS::TQoSR5Requested r5;
 
   378             RPacketQoS::TQoSR5Requested r5;
 
   378 			aContext.QosRequested() = r4;
 
   384 			aContext.QosRequested() = r4;
 
   379 #endif 
   385 #endif 
   380 // SYMBIAN_NETWORKING_UMTSR5
 
   386 // SYMBIAN_NETWORKING_UMTSR5
 
   381 
   387 
   382 
   388 
   383 #ifdef _DEBUG
 
   389 #if (OST_TRACE_CATEGORY & OST_TRACE_CATEGORY_DEBUG)
 
   384             aContext.DumpReqProfileParameters ();
 
   390             aContext.DumpReqProfileParameters ();
 
   385 #endif			
   391 #endif			
   386 			aContext.PacketQoS().SetProfileParameters (*aStatus, aContext.QosRequestedPckg());
 
   392 			aContext.PacketQoS().SetProfileParameters (*aStatus, aContext.QosRequestedPckg());
 
   387 			aContext.SetStrategyStep (ESetProfileParamsStep);
 
   393 			aContext.SetStrategyStep (ESetProfileParamsStep);
 
   388 			break;
 
   394 			break;
 
   393 			aContext.SetStrategyStep (EFinishStep);
 
   399 			aContext.SetStrategyStep (EFinishStep);
 
   394 			break;
 
   400 			break;
 
   395 			}
 
   401 			}
 
   396 			
   402 			
   397 		default:
 
   403 		default:
 
   398 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   404 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NEXT_4, "ERROR: Incorrect case");
 
   399 			ASSERT(EFalse);
 
   405 			ASSERT(EFalse);
 
   400 			err = KErrNotSupported;
 
   406 			err = KErrNotSupported;
 
   401 			break;
 
   407 			break;
 
   402 		}
 
   408 		}
 
   403 		
   409 		
   417 */	
   423 */	
   418 void TCreate1ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
   424 void TCreate1ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
   419 {
 
   425 {
 
   420 	if(aCompletionStatus == KErrNone)
 
   426 	if(aCompletionStatus == KErrNone)
 
   421 		{
 
   427 		{
 
   422 		SPUDTEL_INFO_LOG(_L("Notifying FSM: E1ryPdpContextCreated"));
 
   428 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NOTIFYFSM_1, "Notifying FSM: E1ryPdpContextCreated");
 
   423 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreated);
 
   429 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreated);
 
   424 		}
 
   430 		}
 
   425 	else
 
   431 	else
 
   426 		{
 
   432 		{
 
   427 		SPUDTEL_INFO_LOG(_L("Notifying FSM: E1ryPdpContextCreatedFailed"));
 
   433 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_NOTIFYFSM_2, "Notifying FSM: E1ryPdpContextCreatedFailed");
 
   428 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreatedFailed, aCompletionStatus.Int());
 
   434 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreatedFailed, aCompletionStatus.Int());
 
   429 		}
 
   435 		}
 
   430 }
 
   436 }
 
   431 
   437 
   432 /** Cancels last asynchronous request to eTel
 
   438 /** Cancels last asynchronous request to eTel
 
   433 
   439 
   434 @param  aContext - pdp context
 
   440 @param  aContext - pdp context
 
   435 */
 
   441 */
 
   436 void TCreate1ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
   442 void TCreate1ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
   437 	{
 
   443 	{
 
   438 	SPUDTEL_FNLOG("TCreate1ryPdpContextStrategy::CancelAsyncRequest()");
 
   444 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_1, "TCreate1ryPdpContextStrategy::CancelAsyncRequest()");
 
   439 	
   445 	
   440 	switch(aContext.StrategyStep())
 
   446 	switch(aContext.StrategyStep())
 
   441 		{
 
   447 		{
 
   442 		case ESetConfigStep:
 
   448 		case ESetConfigStep:
 
   443 			{
 
   449 			{
 
   444 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextSetConfig"));
 
   450 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketContext::EPacketContextSetConfig");
 
   445 			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
   451 			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
   446 			break;
 
   452 			break;
 
   447 			}
 
   453 			}
 
   448 			
   454 			
   449 		case ESetProfileParamsStep:
 
   455 		case ESetProfileParamsStep:
 
   450 			{
 
   456 			{
 
   451 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketQoSSetProfileParams"));
 
   457 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_3, "Cancel PacketContext::EPacketQoSSetProfileParams");
 
   452 			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);
 
   458 			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);
 
   453 			break;
 
   459 			break;
 
   454 			}
 
   460 			}
 
   455 			
   461 			
   456 		case EInitialiseContextStep:
 
   462 		case EInitialiseContextStep:
 
   457 		    SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextInitialiseContext"));
 
   463 		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_4, "Cancel PacketContext::EPacketContextInitialiseContext");
 
   458 		    aContext.PacketContext().CancelAsyncRequest(EPacketContextInitialiseContext);
 
   464 		    aContext.PacketContext().CancelAsyncRequest(EPacketContextInitialiseContext);
 
   459 		    break;
 
   465 		    break;
 
   460 			
   466 			
   461 		default:
 
   467 		default:
 
   462 			// there're NO outstanding async requests
 
   468 			// there're NO outstanding async requests
 
   463 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   469 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE1RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_5, "ERROR: Incorrect case");
 
   464 			ASSERT(EFalse);
 
   470 			ASSERT(EFalse);
 
   465 			break;
 
   471 			break;
 
   466 		}
 
   472 		}
 
   467 	}
 
   473 	}
 
   468 
   474 
   475 @param aContext - pdp context
 
   481 @param aContext - pdp context
 
   476 @param aStatus - request status of this step
 
   482 @param aStatus - request status of this step
 
   477 */
 
   483 */
 
   478 void TCreate2ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   484 void TCreate2ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   479 	{
 
   485 	{
 
   480 	SPUDTEL_FNLOG("TCreate2ryPdpContextStrategy::Next()");
 
   486 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_NEXT_1, "TCreate2ryPdpContextStrategy::Next()");
 
   481 	
   487 	
   482 	TInt err = KErrNone;
 
   488 	TInt err = KErrNone;
 
   483 	
   489 	
   484 	// possible steps:
 
   490 	// possible steps:
 
   485 	//	-- open new secondary context
 
   491 	//	-- open new secondary context
 
   500 			// QoS name is not used anywhere
 
   506 			// QoS name is not used anywhere
 
   501 			TName newName;
 
   507 			TName newName;
 
   502 			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);
 
   508 			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);
 
   503 			if (err)
 
   509 			if (err)
 
   504 				{ 
   510 				{ 
   505 				SPUDTEL_ERROR_LOG(_L("PacketQoS OpenNewQoS returned %d"), err);
 
   511 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_NEXT_2, "PacketQoS OpenNewQoS returned %d", err);
 
   506 				break; 
   512 				break; 
   507 				}
 
   513 				}
 
   508 			aContext.SetStrategyStep (EFinishStep);
 
   514 			aContext.SetStrategyStep (EFinishStep);
 
   509 			break;
 
   515 			break;
 
   510 			}
 
   516 			}
 
   511 			
   517 			
   512 		default:
 
   518 		default:
 
   513 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   519 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_NEXT_3, "ERROR: Incorrect case");
 
   514 			ASSERT(EFalse);
 
   520 			ASSERT(EFalse);
 
   515 			err = KErrNotSupported;
 
   521 			err = KErrNotSupported;
 
   516 			break;
 
   522 			break;
 
   517 		}
 
   523 		}
 
   518 		
   524 		
   532 */	
   538 */	
   533 void TCreate2ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   539 void TCreate2ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   534 {
 
   540 {
 
   535 	if(aCompletionStatus == KErrNone)
 
   541 	if(aCompletionStatus == KErrNone)
 
   536 		{
 
   542 		{
 
   537 		SPUDTEL_INFO_LOG(_L("Notifying FSM: E2ryPdpContextCreated"));
 
   543 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_NOTIFYFSM_1, "Notifying FSM: E2ryPdpContextCreated");
 
   538 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E2ryPdpContextCreated);
 
   544 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E2ryPdpContextCreated);
 
   539 		}
 
   545 		}
 
   540 	else
 
   546 	else
 
   541 		{
 
   547 		{
 
   542 		SPUDTEL_INFO_LOG(_L("Notifying FSM: E2ryPdpContextCreatedFailed"));
 
   548 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_NOTIFYFSM_2, "Notifying FSM: E2ryPdpContextCreatedFailed");
 
   543 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E2ryPdpContextCreatedFailed, aCompletionStatus.Int());
 
   549 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E2ryPdpContextCreatedFailed, aCompletionStatus.Int());
 
   544 		}
 
   550 		}
 
   545 }
 
   551 }
 
   546 
   552 
   547 /** Cancels last asynchronous request to eTel
 
   553 /** Cancels last asynchronous request to eTel
 
   548 
   554 
   549 @param  aContext - pdp context
 
   555 @param  aContext - pdp context
 
   550 */
 
   556 */
 
   551 void TCreate2ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& /*aContext*/)
 
   557 void TCreate2ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& /*aContext*/)
 
   552 	{
 
   558 	{
 
   553 	SPUDTEL_FNLOG("TCreate2ryPdpContextStrategy::CancelAsyncRequest()");
 
   559 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_1, "TCreate2ryPdpContextStrategy::CancelAsyncRequest()");
 
   554 	SPUDTEL_ERROR_LOG0(_L("ERROR: No outstanding requests"));
 
   560 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATE2RYPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_2, "ERROR: No outstanding requests");
 
   555 	}
 
   561 	}
 
   556 
   562 
   557 
   563 
   558 //
 
   564 //
 
   559 // TSetQoSStrategy
 
   565 // TSetQoSStrategy
 
   563 @param aContext - pdp context
 
   569 @param aContext - pdp context
 
   564 @param aStatus - request status of this step
 
   570 @param aStatus - request status of this step
 
   565 */
 
   571 */
 
   566 void TSetQoSStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   572 void TSetQoSStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   567 	{
 
   573 	{
 
   568 	SPUDTEL_FNLOG("TSetQoSStrategy::Next()");
 
   574 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_NEXT_1, "TSetQoSStrategy::Next()");
 
   569 	
   575 	
   570 	TInt err = KErrNone;
 
   576 	TInt err = KErrNone;
 
   571 	
   577 	
   572 	// possible steps:
 
   578 	// possible steps:
 
   573 	//	-- set QoS profile parameters
 
   579 	//	-- set QoS profile parameters
 
   584 
   590 
   585 			aContext.PdpFsmInterface().Get (aContext.Id(), req);
 
   591 			aContext.PdpFsmInterface().Get (aContext.Id(), req);
 
   586 			aContext.QosRequested() = req;	
   592 			aContext.QosRequested() = req;	
   587 
   593 
   588 
   594 
   589 #ifdef _DEBUG
 
   595 #if (OST_TRACE_CATEGORY & OST_TRACE_CATEGORY_DEBUG)
 
   590             aContext.DumpReqProfileParameters ();
 
   596             aContext.DumpReqProfileParameters ();
 
   591 #endif			
   597 #endif			
   592             aContext.PacketQoS().SetProfileParameters (*aStatus, aContext.QosRequestedPckg());
 
   598             aContext.PacketQoS().SetProfileParameters (*aStatus, aContext.QosRequestedPckg());
 
   593 			aContext.SetStrategyStep (ESetProfileParamsStep);
 
   599 			aContext.SetStrategyStep (ESetProfileParamsStep);
 
   594 			break;
 
   600 			break;
 
   601 			}
 
   607 			}
 
   602 			
   608 			
   603 		default:
 
   609 		default:
 
   604 			{
 
   610 			{
 
   605 			// unexpected
 
   611 			// unexpected
 
   606 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   612 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
   607 			ASSERT(EFalse);
 
   613 			ASSERT(EFalse);
 
   608 			err = KErrNotSupported;
 
   614 			err = KErrNotSupported;
 
   609 			break;
 
   615 			break;
 
   610 			}
 
   616 			}
 
   611 		}
 
   617 		}
 
   624 */	
   630 */	
   625 void TSetQoSStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   631 void TSetQoSStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   626 	{
 
   632 	{
 
   627 	if(aCompletionStatus == KErrNone)
 
   633 	if(aCompletionStatus == KErrNone)
 
   628 		{
 
   634 		{
 
   629 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EQoSSet"));
 
   635 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_NOTIFYFSM_1, "Notifying FSM: EQoSSet");
 
   630 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EQoSSet);
 
   636 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EQoSSet);
 
   631 		}
 
   637 		}
 
   632 	else
 
   638 	else
 
   633 		{
 
   639 		{
 
   634 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EQoSSetFailed"));
 
   640 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_NOTIFYFSM_2, "Notifying FSM: EQoSSetFailed");
 
   635 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EQoSSetFailed, aCompletionStatus.Int());
 
   641 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EQoSSetFailed, aCompletionStatus.Int());
 
   636 		}
 
   642 		}
 
   637 	}
 
   643 	}
 
   638 	
   644 	
   639 /** Cancels last asynchronous request to eTel
 
   645 /** Cancels last asynchronous request to eTel
 
   645 	switch(aContext.StrategyStep())
 
   651 	switch(aContext.StrategyStep())
 
   646 		{
 
   652 		{
 
   647 		case ESetProfileParamsStep:
 
   653 		case ESetProfileParamsStep:
 
   648 			{
 
   654 			{
 
   649 			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);
 
   655 			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);
 
   650 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketQoSSetProfileParams"));
 
   656 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketQoS::EPacketQoSSetProfileParams");
 
   651 			break;
 
   657 			break;
 
   652 			}
 
   658 			}
 
   653 			
   659 			
   654 		default:
 
   660 		default:
 
   655 			// there're NO outstanding async requests
 
   661 			// there're NO outstanding async requests
 
   656 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TSetQoSStrategy::CancelAsyncRequest"));
 
   662 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETQOSSTRATEGY_CANCELASYNCREQUEST_2, "ERROR: Incorrect case in TSetQoSStrategy::CancelAsyncRequest");
 
   657 			ASSERT(EFalse);
 
   663 			ASSERT(EFalse);
 
   658 			break;
 
   664 			break;
 
   659 		}
 
   665 		}
 
   660 	}
 
   666 	}
 
   661 
   667 
   668 @param aContext - pdp context
 
   674 @param aContext - pdp context
 
   669 @param aStatus - request status of this step
 
   675 @param aStatus - request status of this step
 
   670 */
 
   676 */
 
   671 void TSetTftStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   677 void TSetTftStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   672 	{
 
   678 	{
 
   673 	SPUDTEL_FNLOG("TSetTftStrategy::Next()");
 
   679 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_1, "TSetTftStrategy::Next()");
 
   674 	
   680 	
   675 	TInt err = KErrNone;
 
   681 	TInt err = KErrNone;
 
   676 
   682 
   677 	// possible steps:
 
   683 	// possible steps:
 
   678 	// 	-- add filters
 
   684 	// 	-- add filters
 
   683 			aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftOperationCode());
 
   689 			aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftOperationCode());
 
   684 			switch(aContext.TftOperationCode())
 
   690 			switch(aContext.TftOperationCode())
 
   685 				{
 
   691 				{
 
   686 				case KAddFilters:
 
   692 				case KAddFilters:
 
   687 					aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   693 					aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   688 					SPUDTELVERBOSE_INFO_LOG1(_L("TftOperationCode - Add Filters"), aContext.TftInfo().FilterCount());
 
   694 					OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_2, "TftOperationCode - Add Filters %d", aContext.TftInfo().FilterCount());
 
   689 					// Set strategy assumes that TFT has to be created on a first place
 
   695 					// Set strategy assumes that TFT has to be created on a first place
 
   690 					SPUDTELVERBOSE_INFO_LOG(_L("Creating TFT..."));
 
   696 					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_3, "Creating TFT...");
 
   691 					if (aContext.ContextType() != SpudMan::EMbms)
 
   697 					if (aContext.ContextType() != SpudMan::EMbms)
 
   692 						{	
   698 						{	
   693 						aContext.PacketContext().CreateNewTFT(*aStatus, aContext.TftInfo().FilterCount());
 
   699 						aContext.PacketContext().CreateNewTFT(*aStatus, aContext.TftInfo().FilterCount());
 
   694 						}
 
   700 						}
 
   695 					else
 
   701 					else
 
   699 					aContext.SetStrategyStep (ECreateNewTFTStep);
 
   705 					aContext.SetStrategyStep (ECreateNewTFTStep);
 
   700 					break;
 
   706 					break;
 
   701 
   707 
   702 				case KRemoveFilters:
 
   708 				case KRemoveFilters:
 
   703 					err = KErrNotSupported;
 
   709 					err = KErrNotSupported;
 
   704 					SPUDTEL_ERROR_LOG(_L("TftOperationCode - Remove is not supported in a Set strategy, return %d"), err);
 
   710 					OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_4, "TftOperationCode - Remove is not supported in a Set strategy, return %d", err);
 
   705 					break;
 
   711 					break;
 
   706 
   712 
   707 				case KDeleteTFT:
 
   713 				case KDeleteTFT:
 
   708 					err = KErrNotSupported;
 
   714 					err = KErrNotSupported;
 
   709 					SPUDTEL_ERROR_LOG(_L("TftOperationCode - Delete is not supported in a Set strategy, return %d"), err);
 
   715 					OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_5, "TftOperationCode - Delete is not supported in a Set strategy, return %d", err);
 
   710 					break;
 
   716 					break;
 
   711 
   717 
   712 				default:
 
   718 				default:
 
   713 					// wrong case
 
   719 					// wrong case
 
   714 					SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   720 					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_6, "ERROR: Incorrect case");
 
   715 					ASSERT(EFalse);
 
   721 					ASSERT(EFalse);
 
   716 					err = KErrNotSupported;
 
   722 					err = KErrNotSupported;
 
   717 					break;
 
   723 					break;
 
   718 				}
 
   724 				}
 
   719 			break;
 
   725 			break;
 
   769 			break;
 
   775 			break;
 
   770 			}
 
   776 			}
 
   771 
   777 
   772 		default:
 
   778 		default:
 
   773 			// unexpected
 
   779 			// unexpected
 
   774 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   780 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NEXT_7, "ERROR: Incorrect case");
 
   775 			ASSERT(EFalse);
 
   781 			ASSERT(EFalse);
 
   776 			err = KErrNotSupported;
 
   782 			err = KErrNotSupported;
 
   777 			break;
 
   783 			break;
 
   778 		}
 
   784 		}
 
   779 		
   785 		
   792 */	
   798 */	
   793 void TSetTftStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   799 void TSetTftStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
   794 	{
 
   800 	{
 
   795 	if(aCompletionStatus == KErrNone)
 
   801 	if(aCompletionStatus == KErrNone)
 
   796 		{
 
   802 		{
 
   797 		SPUDTEL_INFO_LOG(_L("Notifying FSM: ETftSet"));
 
   803 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NOTIFYFSM_1, "Notifying FSM: ETftSet");
 
   798 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftSet);
 
   804 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftSet);
 
   799 		}
 
   805 		}
 
   800 	else
 
   806 	else
 
   801 		{
 
   807 		{
 
   802 		SPUDTEL_INFO_LOG(_L("Notifying FSM: ETftSetFailed"));
 
   808 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_NOTIFYFSM_2, "Notifying FSM: ETftSetFailed");
 
   803 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftSetFailed, aCompletionStatus.Int());
 
   809 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftSetFailed, aCompletionStatus.Int());
 
   804 		}
 
   810 		}
 
   805 	}
 
   811 	}
 
   806 	
   812 	
   807 /** Cancels last asynchronous request to eTel
 
   813 /** Cancels last asynchronous request to eTel
 
   813 	switch(aContext.StrategyStep())
 
   819 	switch(aContext.StrategyStep())
 
   814 		{
 
   820 		{
 
   815 		case ECreateNewTFTStep:
 
   821 		case ECreateNewTFTStep:
 
   816 			{
 
   822 			{
 
   817 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextCreateNewTFT);
 
   823 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextCreateNewTFT);
 
   818 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketContextCreateNewTFT"));
 
   824 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketQoS::EPacketContextCreateNewTFT");
 
   819 			break;
 
   825 			break;
 
   820 			}
 
   826 			}
 
   821 			
   827 			
   822 		case EAddTftStep:
 
   828 		case EAddTftStep:
 
   823 			{
 
   829 			{
 
   824 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextAddPacketFilter);
 
   830 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextAddPacketFilter);
 
   825 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketContextAddPacketFilter"));
 
   831 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketQoS::EPacketContextAddPacketFilter");
 
   826 			break;
 
   832 			break;
 
   827 			}
 
   833 			}
 
   828 
   834 
   829 		default:
 
   835 		default:
 
   830 			// unexpected
 
   836 			// unexpected
 
   831 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TSetTftStrategy::CancelAsyncRequest"));
 
   837 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSETTFTSTRATEGY_CANCELASYNCREQUEST_3, "ERROR: Incorrect case in TSetTftStrategy::CancelAsyncRequest");
 
   832 			ASSERT(EFalse);
 
   838 			ASSERT(EFalse);
 
   833 			break;
 
   839 			break;
 
   834 		}
 
   840 		}
 
   835 	}
 
   841 	}
 
   836 
   842 
   843 @param aContext - pdp context
 
   849 @param aContext - pdp context
 
   844 @param aStatus - request status of this step
 
   850 @param aStatus - request status of this step
 
   845 */
 
   851 */
 
   846 void TChangeTftStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   852 void TChangeTftStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
   847 	{
 
   853 	{
 
   848 	SPUDTEL_FNLOG("TChangeTftStrategy::Next()");
 
   854 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_1, "TChangeTftStrategy::Next()");
 
   849 	
   855 	
   850 	TInt err = KErrNone;
 
   856 	TInt err = KErrNone;
 
   851 
   857 
   852 	// special case. 
   858 	// special case. 
   853 	if(EStartStep == aContext.StrategyStep())
 
   859 	if(EStartStep == aContext.StrategyStep())
 
   855 		aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftOperationCode());
 
   861 		aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftOperationCode());
 
   856 		switch(aContext.TftOperationCode())
 
   862 		switch(aContext.TftOperationCode())
 
   857 			{
 
   863 			{
 
   858 			case KAddFilters:
 
   864 			case KAddFilters:
 
   859 				aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   865 				aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   860 				SPUDTELVERBOSE_INFO_LOG1(_L("TftOperationCode - Add Filters"), aContext.TftInfo().FilterCount());
 
   866 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_2, "TftOperationCode - Add Filters %d", aContext.TftInfo().FilterCount());
 
   861 				aContext.SetStrategyStep (EAddFirstTftStep);
 
   867 				aContext.SetStrategyStep (EAddFirstTftStep);
 
   862 				break;
 
   868 				break;
 
   863 
   869 
   864 			case KRemoveFilters:
 
   870 			case KRemoveFilters:
 
   865 				aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   871 				aContext.PdpFsmInterface().Get (aContext.Id(), aContext.TftInfo());
 
   866 				SPUDTELVERBOSE_INFO_LOG1(_L("TftOperationCode - Remove %d Filters"), aContext.TftInfo().FilterCount());
 
   872 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_3, "TftOperationCode - Remove %d Filters", aContext.TftInfo().FilterCount());
 
   867 				aContext.SetStrategyStep (ERemoveFirstTftStep);
 
   873 				aContext.SetStrategyStep (ERemoveFirstTftStep);
 
   868 				break;
 
   874 				break;
 
   869 
   875 
   870 			case KDeleteTFT:
 
   876 			case KDeleteTFT:
 
   871 				SPUDTELVERBOSE_INFO_LOG(_L("TftOperationCode - Delete TFT"));
 
   877 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_4, "TftOperationCode - Delete TFT");
 
   872 				// delete old TFT
 
   878 				// delete old TFT
 
   873 				aContext.PacketContext().DeleteTFT(*aStatus);
 
   879 				aContext.PacketContext().DeleteTFT(*aStatus);
 
   874 				aContext.SetStrategyStep (EDeleteTftStep);
 
   880 				aContext.SetStrategyStep (EDeleteTftStep);
 
   875 				// DeleteTFT() ia an async operation => return 
   881 				// DeleteTFT() ia an async operation => return 
   876 				return;
 
   882 				return;
 
   877 
   883 
   878 			default:
 
   884 			default:
 
   879 				// wrong case
 
   885 				// wrong case
 
   880 				SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
   886 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_5, "ERROR: Incorrect case");
 
   881 				ASSERT(EFalse);
 
   887 				ASSERT(EFalse);
 
   882 				err = KErrNotSupported;
 
   888 				err = KErrNotSupported;
 
   883 				break;
 
   889 				break;
 
   884 			}
 
   890 			}
 
   885 		}
 
   891 		}
 
  1002 				break;
 
  1008 				break;
 
  1003 
  1009 
  1004 				
  1010 				
  1005 			default:
 
  1011 			default:
 
  1006 				// unexpected
 
  1012 				// unexpected
 
  1007 				SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1013 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NEXT_6, "ERROR: Incorrect case");
 
  1008 				ASSERT(EFalse);
 
  1014 				ASSERT(EFalse);
 
  1009 				err = KErrNotSupported;
 
  1015 				err = KErrNotSupported;
 
  1010 				break;
 
  1016 				break;
 
  1011 			}
 
  1017 			}
 
  1012 		}
 
  1018 		}
 
  1027 */	
  1033 */	
  1028 void TChangeTftStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1034 void TChangeTftStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1029 	{
 
  1035 	{
 
  1030 	if(aCompletionStatus == KErrNone)
 
  1036 	if(aCompletionStatus == KErrNone)
 
  1031 		{
 
  1037 		{
 
  1032 		SPUDTEL_INFO_LOG(_L("Notifying FSM: ETftChanged"));
 
  1038 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NOTIFYFSM_1, "Notifying FSM: ETftChanged");
 
  1033 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftChanged);
 
  1039 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftChanged);
 
  1034 		}
 
  1040 		}
 
  1035 	else
 
  1041 	else
 
  1036 		{
 
  1042 		{
 
  1037 		SPUDTEL_INFO_LOG(_L("Notifying FSM: ETftChangedFailed"));
 
  1043 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_NOTIFYFSM_2, "Notifying FSM: ETftChangedFailed");
 
  1038 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftChangedFailed, aCompletionStatus.Int());
 
  1044 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::ETftChangedFailed, aCompletionStatus.Int());
 
  1039 		}
 
  1045 		}
 
  1040 	}
 
  1046 	}
 
  1041 	
  1047 	
  1042 /** Cancels last asynchronous request to eTel
 
  1048 /** Cancels last asynchronous request to eTel
 
  1047 	{
 
  1053 	{
 
  1048 	switch(aContext.StrategyStep())
 
  1054 	switch(aContext.StrategyStep())
 
  1049 		{
 
  1055 		{
 
  1050 		case EDeleteTftStep:
 
  1056 		case EDeleteTftStep:
 
  1051 			{
 
  1057 			{
 
  1052 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketContextDeleteTFTCancel"));
 
  1058 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketQoS::EPacketContextDeleteTFTCancel");
 
  1053 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextDeleteTFTCancel);
 
  1059 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextDeleteTFTCancel);
 
  1054 			break;
 
  1060 			break;
 
  1055 			}
 
  1061 			}
 
  1056 		
  1062 		
  1057 		case ERemoveTftStep:
 
  1063 		case ERemoveTftStep:
 
  1058 			{
 
  1064 			{
 
  1059 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketContextRemovePacketFilterCancel"));
 
  1065 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketQoS::EPacketContextRemovePacketFilterCancel");
 
  1060 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextRemovePacketFilterCancel);
 
  1066 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextRemovePacketFilterCancel);
 
  1061 			break;
 
  1067 			break;
 
  1062 			}
 
  1068 			}
 
  1063 			
  1069 			
  1064 		case EAddTftStep:
 
  1070 		case EAddTftStep:
 
  1065 			{
 
  1071 			{
 
  1066 			SPUDTEL_INFO_LOG(_L("Cancel PacketQoS::EPacketContextAddPacketFilter"));
 
  1072 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_CANCELASYNCREQUEST_3, "Cancel PacketQoS::EPacketContextAddPacketFilter");
 
  1067 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextAddPacketFilterCancel);
 
  1073 			aContext.PacketQoS().CancelAsyncRequest(EPacketContextAddPacketFilterCancel);
 
  1068 			break;
 
  1074 			break;
 
  1069 			}
 
  1075 			}
 
  1070 
  1076 
  1071 		default:
 
  1077 		default:
 
  1072 			// unexpected
 
  1078 			// unexpected
 
  1073 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TChangeTftStrategy::CancelAsyncRequest"));
 
  1079 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCHANGETFTSTRATEGY_CANCELASYNCREQUEST_4, "ERROR: Incorrect case in TChangeTftStrategy::CancelAsyncRequest");
 
  1074 			ASSERT(EFalse);
 
  1080 			ASSERT(EFalse);
 
  1075 			break;
 
  1081 			break;
 
  1076 		}
 
  1082 		}
 
  1077 	}
 
  1083 	}
 
  1078 
  1084 
  1085 @param aContext - pdp context
 
  1091 @param aContext - pdp context
 
  1086 @param aStatus - request status of this step
 
  1092 @param aStatus - request status of this step
 
  1087 */
 
  1093 */
 
  1088 void TActivatePdpStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1094 void TActivatePdpStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1089 	{
 
  1095 	{
 
  1090 	SPUDTEL_FNLOG("TActivatePdpStrategy::Next()");
 
  1096 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_1, "TActivatePdpStrategy::Next()");
 
  1091 	
  1097 	
  1092 	TInt err = KErrNone;
 
  1098 	TInt err = KErrNone;
 
  1093 	
  1099 	
  1094 	switch(aContext.StrategyStep())
 
  1100 	switch(aContext.StrategyStep())
 
  1095 		{
 
  1101 		{
 
  1096 		case EStartStep:
 
  1102 		case EStartStep:
 
  1097 			{
 
  1103 			{
 
  1098 			SPUDTEL_INFO_LOG(_L("RPacketContext::Activate()"));
 
  1104 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_3, "RPacketContext::Activate()");
 
  1099 			aContext.PacketContext().Activate(*aStatus);
 
  1105 			aContext.PacketContext().Activate(*aStatus);
 
  1100 			aContext.SetStrategyStep (EActivateStep);
 
  1106 			aContext.SetStrategyStep (EActivateStep);
 
  1101 			break;
 
  1107 			break;
 
  1102 			}
 
  1108 			}
 
  1103 		
  1109 		
  1104 		case EActivateStep:
 
  1110 		case EActivateStep:
 
  1105 		case ENotifyStatusChange:
 
  1111 		case ENotifyStatusChange:
 
  1106 			{
 
  1112 			{
 
  1107             SPUDTEL_INFO_LOG(_L("RPacketContext::GetStatus()"));
 
  1113             OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_4, "RPacketContext::GetStatus()");
 
       
  1114 
  1108             if (aContext.PacketContext().GetStatus(aContext.ContextStatus()) != KErrNone)
 
  1115             if (aContext.PacketContext().GetStatus(aContext.ContextStatus()) != KErrNone)
 
  1109                 {
 
  1116                 {
 
  1110                 aContext.ContextStatus() = RPacketContext::EStatusInactive;
 
  1117                 aContext.ContextStatus() = RPacketContext::EStatusInactive;
 
  1111                 }
 
  1118                 }
 
  1112             
  1119             
  1113             switch (aContext.ContextStatus())
 
  1120             switch (aContext.ContextStatus())
 
  1114             	{
 
  1121             	{
 
  1115             	case RPacketContext::EStatusActive:
 
  1122             	case RPacketContext::EStatusActive:
 
  1116                 	// Context is now active
 
  1123                 	// Context is now active
 
  1117     	            aContext.PdpFsmInterface().Get (aContext.Id(), aContext.ContextPacketDataConfigBase());
 
  1124     	            aContext.PdpFsmInterface().Get (aContext.Id(), aContext.ContextPacketDataConfigBase());
 
  1118     	            SPUDTEL_INFO_LOG(_L("RPacketContext::GetConfig()"));
 
  1125     	            OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_5, "RPacketContext::GetConfig()");
 
  1119     				aContext.PacketContext().GetConfig (*aStatus, aContext.ContextConfig());
 
  1126     				aContext.PacketContext().GetConfig (*aStatus, aContext.ContextConfig());
 
  1120     				aContext.SetStrategyStep (EGetConfigStep);
 
  1127     				aContext.SetStrategyStep (EGetConfigStep);
 
  1121     				break;
 
  1128     				break;
 
  1122 
  1129 
  1123             	case RPacketContext::EStatusInactive:
 
  1130             	case RPacketContext::EStatusInactive:
 
  1154                     break;
 
  1161                     break;
 
  1155                     }
 
  1162                     }
 
  1156             	
  1163             	
  1157             	default:
 
  1164             	default:
 
  1158             		// Not active, not inactive. Re-request the status and try again
 
  1165             		// Not active, not inactive. Re-request the status and try again
 
  1159             	    SPUDTEL_INFO_LOG(_L("RPacketContext::NotifyStatusChange()"));
 
  1166                     OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_6, "RPacketContext::NotifyStatusChange()");
 
  1160                     aContext.PacketContext().NotifyStatusChange(*aStatus, aContext.ContextStatus());
 
  1167                     aContext.PacketContext().NotifyStatusChange(*aStatus, aContext.ContextStatus());
 
  1161                     aContext.SetStrategyStep (ENotifyStatusChange);
 
  1168                     aContext.SetStrategyStep (ENotifyStatusChange);
 
  1162                     break;
 
  1169                     break;
 
  1163                 }
 
  1170                 }
 
  1164 			break;
 
  1171 			break;
 
  1168 			{
 
  1175 			{
 
  1169 			aContext.PdpFsmInterface().Set (aContext.Id(), aContext.ContextPacketDataConfigBase());
 
  1176 			aContext.PdpFsmInterface().Set (aContext.Id(), aContext.ContextPacketDataConfigBase());
 
  1170 			if (KPrimaryContextId == aContext.Id())
 
  1177 			if (KPrimaryContextId == aContext.Id())
 
  1171 				{
 
  1178 				{
 
  1172                 aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());	
  1179                 aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());	
  1173 #ifdef _DEBUG
 
  1180 #if (OST_TRACE_CATEGORY & OST_TRACE_CATEGORY_DEBUG)
 
  1174                 aContext.DumpNegProfileParameters ();
 
  1181                 aContext.DumpNegProfileParameters ();
 
  1175 #endif
 
  1182 #endif
 
  1176                 aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1183                 aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1177                 }
 
  1184                 }
 
  1178 			else
 
  1185 			else
 
  1198 			break;
 
  1205 			break;
 
  1199 			}
 
  1206 			}
 
  1200 			
  1207 			
  1201 		default:
 
  1208 		default:
 
  1202 			// unexpected
 
  1209 			// unexpected
 
  1203 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1210 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
  1204 			ASSERT(EFalse);
 
  1211 			ASSERT(EFalse);
 
  1205 			err = KErrNotSupported;
 
  1212 			err = KErrNotSupported;
 
  1206 			break;
 
  1213 			break;
 
  1207 		}
 
  1214 		}
 
  1208 		
  1215 		
  1222 */	
  1229 */	
  1223 void TActivatePdpStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1230 void TActivatePdpStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1224 	{
 
  1231 	{
 
  1225 	if(aCompletionStatus == KErrNone)
 
  1232 	if(aCompletionStatus == KErrNone)
 
  1226 		{
 
  1233 		{
 
  1227 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: DataChannelV2"));
 
  1234 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NOTIFYFSM_1, "FSM set: DataChannelV2");
 
  1228 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.DataChannelV2());
 
  1235 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.DataChannelV2());
 
  1229 
  1236 
  1230 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1237 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1231 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR5Negotiated"));
 
  1238 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NOTIFYFSM_2, "FSM set: QoSR5Negotiated");
 
  1232 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1239 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1233 
  1240 
  1234 #else
 
  1241 #else
 
  1235 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR99_R4Negotiated"));
 
  1242 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NOTIFYFSM_3, "FSM set: QoSR99_R4Negotiated");
 
  1236 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1243 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1237 #endif 
  1244 #endif 
  1238 // SYMBIAN_NETWORKING_UMTSR5
 
  1245 // SYMBIAN_NETWORKING_UMTSR5
 
  1239 
  1246 
  1240 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpActivated"));
 
  1247 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NOTIFYFSM_4, "Notifying FSM: EPdpActivated");
 
  1241 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivated);
 
  1248 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivated);
 
  1242 
  1249 
  1243 		}
 
  1250 		}
 
  1244 	else
 
  1251 	else
 
  1245 		{
 
  1252 		{
 
  1246 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpActivatedFailed"));
 
  1253 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_NOTIFYFSM_5, "Notifying FSM: EPdpActivatedFailed");
 
  1247 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivatedFailed, aCompletionStatus.Int());
 
  1254 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivatedFailed, aCompletionStatus.Int());
 
  1248 		}
 
  1255 		}
 
  1249 	}
 
  1256 	}
 
  1250 	
  1257 	
  1251 /** Cancels last asynchronous request to eTel
 
  1258 /** Cancels last asynchronous request to eTel
 
  1256 	{
 
  1263 	{
 
  1257 	switch(aContext.StrategyStep())
 
  1264 	switch(aContext.StrategyStep())
 
  1258 		{
 
  1265 		{
 
  1259 		case EActivateStep:
 
  1266 		case EActivateStep:
 
  1260 			{
 
  1267 			{
 
  1261             SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextActivate"));
 
  1268 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketContext::EPacketContextActivate");
 
  1262 			aContext.PacketContext().CancelAsyncRequest(EPacketContextActivate);
 
  1269 			aContext.PacketContext().CancelAsyncRequest(EPacketContextActivate);
 
  1263 			break;
 
  1270 			break;
 
  1264 			}
 
  1271 			}
 
  1265 			
  1272 			
  1266 		case EGetConfigStep:
 
  1273 		case EGetConfigStep:
 
  1267 			{
 
  1274 			{
 
  1268 	        SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextGetConfig"));
 
  1275 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketContext::EPacketContextGetConfig");
 
  1269 			aContext.PacketContext().CancelAsyncRequest(EPacketContextGetConfig);
 
  1276 			aContext.PacketContext().CancelAsyncRequest(EPacketContextGetConfig);
 
  1270 			break;
 
  1277 			break;
 
  1271 			}
 
  1278 			}
 
  1272 					
  1279 		
  1273 		case ENotifyStatusChange:
 
  1280 		case ENotifyStatusChange:
 
  1274 		    {
 
  1281 		    {
 
  1275             SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextNotifyStatusChange"));
 
  1282 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_CANCELASYNCREQUEST_3, "Cancel PacketContext::EPacketContextNotifyStatusChange");
 
  1276             aContext.PacketContext().CancelAsyncRequest(EPacketContextNotifyStatusChange);
 
  1283 			aContext.PacketContext().CancelAsyncRequest(EPacketContextNotifyStatusChange);	
  1277             break;
 
  1284 			break;
 
  1278 		    }
 
  1285 			}
 
  1279 		    
  1286 			
  1280 		case EGetProfileParamsStep:
 
  1287 		case EGetProfileParamsStep:
 
  1281 			{
 
  1288 			{
 
  1282 			if(KPrimaryContextId == aContext.Id())
 
  1289 			if(KPrimaryContextId == aContext.Id())
 
  1283 				{
 
  1290 				{
 
  1284                 SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketQoSGetProfileParams"));
 
  1291 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_CANCELASYNCREQUEST_4, "Cancel PacketContext::EPacketQoSGetProfileParams");
 
  1285 				aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);	
  1292 				aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);	
  1286 				break;
 
  1293 				break;
 
  1287 				}
 
  1294 				}
 
  1288 			}
 
  1295 			}
 
  1289 			
  1296 			
  1290 		default:
 
  1297 		default:
 
  1291 			// unexpected
 
  1298 			// unexpected
 
  1292 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TActivatePdpStrategy::CancelAsyncRequest"));
 
  1299 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEPDPSTRATEGY_CANCELASYNCREQUEST_5, "ERROR: Incorrect case in TActivatePdpStrategy::CancelAsyncRequest");
 
  1293 			ASSERT(EFalse);
 
  1300 			ASSERT(EFalse);
 
  1294 			break;
 
  1301 			break;
 
  1295 		}
 
  1302 		}
 
  1296 	}
 
  1303 	}
 
  1297 
  1304 
  1303 @param aContext - pdp context
 
  1310 @param aContext - pdp context
 
  1304 @param aStatus - request status of this step
 
  1311 @param aStatus - request status of this step
 
  1305 */
 
  1312 */
 
  1306 void TGetNegQoSStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1313 void TGetNegQoSStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1307 	{
 
  1314 	{
 
  1308 	SPUDTEL_FNLOG("TGetNegQoSStrategy::Next()");
 
  1315 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NEXT_1, "TGetNegQoSStrategy::Next()");
 
  1309 	
  1316 	
  1310 	TInt err = KErrNone;
 
  1317 	TInt err = KErrNone;
 
  1311 	
  1318 	
  1312 	switch(aContext.StrategyStep())
 
  1319 	switch(aContext.StrategyStep())
 
  1313 		{
 
  1320 		{
 
  1314 		case EStartStep:
 
  1321 		case EStartStep:
 
  1315 			{
 
  1322 			{
 
  1316 			aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());
 
  1323 			aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());
 
  1317 #ifdef _DEBUG
 
  1324 #if (OST_TRACE_CATEGORY & OST_TRACE_CATEGORY_DEBUG)
 
  1318             aContext.DumpNegProfileParameters ();
 
  1325             aContext.DumpNegProfileParameters ();
 
  1319 #endif
 
  1326 #endif
 
  1320 			aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1327 			aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1321 			break;
 
  1328 			break;
 
  1322 			}
 
  1329 			}
 
  1327 			break;
 
  1334 			break;
 
  1328 			}
 
  1335 			}
 
  1329 			
  1336 			
  1330 		default:
 
  1337 		default:
 
  1331 			// unexpected
 
  1338 			// unexpected
 
  1332 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1339 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
  1333 			ASSERT(EFalse);
 
  1340 			ASSERT(EFalse);
 
  1334 			err = KErrNotSupported;
 
  1341 			err = KErrNotSupported;
 
  1335 			break;
 
  1342 			break;
 
  1336 		}
 
  1343 		}
 
  1337 		
  1344 		
  1352 void TGetNegQoSStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1359 void TGetNegQoSStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1353 	{
 
  1360 	{
 
  1354 	if(aCompletionStatus == KErrNone)
 
  1361 	if(aCompletionStatus == KErrNone)
 
  1355 		{
 
  1362 		{
 
  1356 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1363 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1357 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR5Negotiated"));
 
  1364 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NOTIFYFSM_1, "FSM set: QoSR5Negotiated");
 
  1358 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1365 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1359 
  1366 
  1360 #else
 
  1367 #else
 
  1361 // !SYMBIAN_NETWORKING_UMTSR5
 
  1368 // !SYMBIAN_NETWORKING_UMTSR5
 
  1362 
  1369 
  1363 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR99_R4Negotiated"));
 
  1370 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NOTIFYFSM_2, "FSM set: QoSR99_R4Negotiated");
 
  1364 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1371 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1365 #endif
 
  1372 #endif
 
  1366 // SYMBIAN_NETWORKING_UMTSR5
 
  1373 // SYMBIAN_NETWORKING_UMTSR5
 
  1367 		
  1374 		
  1368 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpNegQoSRetrieved"));
 
  1375 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NOTIFYFSM_3, "Notifying FSM: EPdpNegQoSRetrieved");
 
  1369 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpNegQoSRetrieved);
 
  1376 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpNegQoSRetrieved);
 
  1370 		}
 
  1377 		}
 
  1371 	else
 
  1378 	else
 
  1372 		{
 
  1379 		{
 
  1373 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpNegQoSRetrievedFailed"));
 
  1380 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_NOTIFYFSM_4, "Notifying FSM: EPdpNegQoSRetrievedFailed");
 
  1374 	 	aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpNegQoSRetrievedFailed, aCompletionStatus.Int());
 
  1381 	 	aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpNegQoSRetrievedFailed, aCompletionStatus.Int());
 
  1375 		}
 
  1382 		}
 
  1376 	}
 
  1383 	}
 
  1377 	
  1384 	
  1378 /** Cancels last asynchronous request to eTel
 
  1385 /** Cancels last asynchronous request to eTel
 
  1384 	switch(aContext.StrategyStep())
 
  1391 	switch(aContext.StrategyStep())
 
  1385 		{	
  1392 		{	
  1386 		case EGetProfileParamsStep:
 
  1393 		case EGetProfileParamsStep:
 
  1387 			{
 
  1394 			{
 
  1388 			aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);	
  1395 			aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);	
  1389 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketQoSGetProfileParams"));
 
  1396 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketContext::EPacketQoSGetProfileParams");
 
  1390 			break;
 
  1397 			break;
 
  1391 			}
 
  1398 			}
 
  1392 			
  1399 			
  1393 		default:
 
  1400 		default:
 
  1394 			// unexpected
 
  1401 			// unexpected
 
  1395 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TGetNegQoSStrategy::CancelAsyncRequest"));
 
  1402 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TGETNEGQOSSTRATEGY_CANCELASYNCREQUEST_2, "ERROR: Incorrect case in TGetNegQoSStrategy::CancelAsyncRequest");
 
  1396 			ASSERT(EFalse);
 
  1403 			ASSERT(EFalse);
 
  1397 			break;
 
  1404 			break;
 
  1398 		}
 
  1405 		}
 
  1399 	}
 
  1406 	}
 
  1400 
  1407 
  1407 @param aContext - pdp context
 
  1414 @param aContext - pdp context
 
  1408 @param aStatus - request status of this step
 
  1415 @param aStatus - request status of this step
 
  1409 */
 
  1416 */
 
  1410 void TModifyActiveStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1417 void TModifyActiveStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1411 	{
 
  1418 	{
 
  1412 	SPUDTEL_FNLOG("TModifyActiveStrategy::Next()");
 
  1419 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NEXT_1, "TModifyActiveStrategy::Next()");
 
  1413 	
  1420 	
  1414 	TInt err = KErrNone;
 
  1421 	TInt err = KErrNone;
 
  1415 	
  1422 	
  1416 	switch(aContext.StrategyStep())
 
  1423 	switch(aContext.StrategyStep())
 
  1417 		{
 
  1424 		{
 
  1432 			}
 
  1439 			}
 
  1433 		
  1440 		
  1434 		case EModifyActiveStep:
 
  1441 		case EModifyActiveStep:
 
  1435 			{
 
  1442 			{
 
  1436 			aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());
 
  1443 			aContext.PacketQoS().GetProfileParameters (*aStatus, aContext.QosNegotiatedPckg());
 
  1437 #ifdef _DEBUG
 
  1444 #if (OST_TRACE_CATEGORY & OST_TRACE_CATEGORY_DEBUG)
 
  1438             aContext.DumpNegProfileParameters ();
 
  1445             aContext.DumpNegProfileParameters ();
 
  1439 #endif
 
  1446 #endif
 
  1440 			aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1447 			aContext.SetStrategyStep (EGetProfileParamsStep);
 
  1441 			break;
 
  1448 			break;
 
  1442 			}
 
  1449 			}
 
  1447 			break;
 
  1454 			break;
 
  1448 			}
 
  1455 			}
 
  1449 			
  1456 			
  1450 		default:
 
  1457 		default:
 
  1451 			// unexpected
 
  1458 			// unexpected
 
  1452 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1459 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
  1453 			ASSERT(EFalse);
 
  1460 			ASSERT(EFalse);
 
  1454 			err = KErrNotSupported;
 
  1461 			err = KErrNotSupported;
 
  1455 			break;
 
  1462 			break;
 
  1456 		}
 
  1463 		}
 
  1457 		
  1464 		
  1474 	if(aCompletionStatus == KErrNone)
 
  1481 	if(aCompletionStatus == KErrNone)
 
  1475 		{
 
  1482 		{
 
  1476 		if(aContext.ContextType() != SpudMan::EMbms)
 
  1483 		if(aContext.ContextType() != SpudMan::EMbms)
 
  1477 			{
 
  1484 			{
 
  1478 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1485 #ifdef SYMBIAN_NETWORKING_UMTSR5
 
  1479 			SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR5Negotiated"));
 
  1486 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NOTIFYFSM_1, "FSM set: QoSR5Negotiated");
 
  1480 			aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1487 			aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR5());
 
  1481 
  1488 
  1482 #else
 
  1489 #else
 
  1483 			SPUDTELVERBOSE_INFO_LOG(_L("FSM set: QoSR99_R4Negotiated"));
 
  1490 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NOTIFYFSM_2, "FSM set: QoSR99_R4Negotiated");
 
  1484  			aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1491  			aContext.PdpFsmInterface().Set(aContext.Id(), aContext.QosNegotiated().NegotiatedQoSR99_R4());
 
  1485 #endif 
  1492 #endif 
  1486 // SYMBIAN_NETWORKING_UMTSR5
 
  1493 // SYMBIAN_NETWORKING_UMTSR5
 
  1487 			}
 
  1494 			}
 
  1488 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpContextModified"));
 
  1495 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NOTIFYFSM_3, "Notifying FSM: EPdpContextModified");
 
  1489 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpContextModified);
 
  1496 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpContextModified);
 
  1490 
  1497 
  1491 		}
 
  1498 		}
 
  1492 	else
 
  1499 	else
 
  1493 		{
 
  1500 		{
 
  1494 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpContextModifiedFailed"));
 
  1501 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_NOTIFYFSM_4, "Notifying FSM: EPdpContextModifiedFailed");
 
  1495 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpContextModifiedFailed, aCompletionStatus.Int());
 
  1502 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpContextModifiedFailed, aCompletionStatus.Int());
 
  1496 		}
 
  1503 		}
 
  1497 	}
 
  1504 	}
 
  1498 	
  1505 	
  1499 /** Cancels last asynchronous request to eTel
 
  1506 /** Cancels last asynchronous request to eTel
 
  1505 	switch(aContext.StrategyStep())
 
  1512 	switch(aContext.StrategyStep())
 
  1506 		{
 
  1513 		{
 
  1507 		case EModifyActiveStep:
 
  1514 		case EModifyActiveStep:
 
  1508 			{
 
  1515 			{
 
  1509 			aContext.PacketContext().CancelAsyncRequest(EPacketContextModifyActiveContext);
 
  1516 			aContext.PacketContext().CancelAsyncRequest(EPacketContextModifyActiveContext);
 
  1510 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextModifyActiveContext"));
 
  1517 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_CANCELASYNCREQUEST_1, "Cancel PacketContext::EPacketContextModifyActiveContext");
 
  1511 			break;
 
  1518 			break;
 
  1512 			}
 
  1519 			}
 
  1513 			
  1520 			
  1514 		case EGetProfileParamsStep:
 
  1521 		case EGetProfileParamsStep:
 
  1515 			{
 
  1522 			{
 
  1516 			aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);
 
  1523 			aContext.PacketContext().CancelAsyncRequest(EPacketQoSGetProfileParams);
 
  1517 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketQoSGetProfileParams"));
 
  1524 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketContext::EPacketQoSGetProfileParams");
 
  1518 			break;
 
  1525 			break;
 
  1519 			}
 
  1526 			}
 
  1520 			
  1527 			
  1521 		default:
 
  1528 		default:
 
  1522 			// unexpected
 
  1529 			// unexpected
 
  1523 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TModifyActiveStrategy::CancelAsyncRequest"));
 
  1530 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMODIFYACTIVESTRATEGY_CANCELASYNCREQUEST_3, "ERROR: Incorrect case in TModifyActiveStrategy::CancelAsyncRequest");
 
  1524 			ASSERT(EFalse);
 
  1531 			ASSERT(EFalse);
 
  1525 			break;
 
  1532 			break;
 
  1526 		}
 
  1533 		}
 
  1527 	}
 
  1534 	}
 
  1528 
  1535 
  1541 @param aContext - pdp context
 
  1548 @param aContext - pdp context
 
  1542 @param aStatus - request status of this step
 
  1549 @param aStatus - request status of this step
 
  1543 */
 
  1550 */
 
  1544 void TCreateMbmsPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1551 void TCreateMbmsPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1545 	{
 
  1552 	{
 
  1546 	SPUDTEL_FNLOG("TCreateMbmsPdpContextStrategy::Next()");
 
  1553 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_NEXT_1, "TCreateMbmsPdpContextStrategy::Next()");
 
  1547 	
  1554 	
  1548 	TInt err = KErrNone;
 
  1555 	TInt err = KErrNone;
 
  1549 	
  1556 	
  1550 	// possible steps:
 
  1557 	// possible steps:
 
  1551 	// 	-- open new context
 
  1558 	// 	-- open new context
 
  1556 		case EStartStep:
 
  1563 		case EStartStep:
 
  1557 			{
 
  1564 			{
 
  1558 			err = aContext.MbmsPacketContext().OpenNewContext (aContext.PacketService(), aContext.Name());
 
  1565 			err = aContext.MbmsPacketContext().OpenNewContext (aContext.PacketService(), aContext.Name());
 
  1559 			if (err)
 
  1566 			if (err)
 
  1560 				{
 
  1567 				{
 
  1561 				SPUDTEL_ERROR_LOG(_L("PacketContextOpenNewContext returned for MBMS %d"), err);
 
  1568 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_NEXT_2, "PacketContextOpenNewContext returned for MBMS %d", err);
 
  1562 				break;
 
  1569 				break;
 
  1563 				}
 
  1570 				}
 
  1564 				
  1571 				
  1565 			aContext.MbmsPacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						
  1572 			aContext.MbmsPacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						
  1566 			aContext.SetStrategyStep (EInitialiseContextStep);
 
  1573 			aContext.SetStrategyStep (EInitialiseContextStep);
 
  1580 		case ESetConfigStep:
 
  1587 		case ESetConfigStep:
 
  1581 			aContext.SetStrategyStep (EFinishStep);
 
  1588 			aContext.SetStrategyStep (EFinishStep);
 
  1582 			break;	
  1589 			break;	
  1583 	
  1590 	
  1584 		default:
 
  1591 		default:
 
  1585 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1592 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_NEXT_3, "ERROR: Incorrect case");
 
  1586 			ASSERT(EFalse);
 
  1593 			ASSERT(EFalse);
 
  1587 			err = KErrNotSupported;
 
  1594 			err = KErrNotSupported;
 
  1588 			break;
 
  1595 			break;
 
  1589 		}
 
  1596 		}
 
  1590 		
  1597 		
  1604 */	
  1611 */	
  1605 void TCreateMbmsPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
  1612 void TCreateMbmsPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)
 
  1606 {
 
  1613 {
 
  1607 	if(aCompletionStatus == KErrNone)
 
  1614 	if(aCompletionStatus == KErrNone)
 
  1608 		{
 
  1615 		{
 
  1609 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EMbmsPdpContextCreated"));
 
  1616 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_NOTIFYFSM_1, "Notifying FSM: EMbmsPdpContextCreated");
 
  1610 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EMbmsPdpContextCreated);
 
  1617 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EMbmsPdpContextCreated);
 
  1611 		}
 
  1618 		}
 
  1612 	else
 
  1619 	else
 
  1613 		{
 
  1620 		{
 
  1614 		SPUDTEL_INFO_LOG(_L("Notifying FSM: E1ryPdpContextCreatedFailed"));
 
  1621 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_NOTIFYFSM_2, "Notifying FSM: E1ryPdpContextCreatedFailed");
 
  1615 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EMbmsPdpContextCreatedFailed, aCompletionStatus.Int());
 
  1622 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EMbmsPdpContextCreatedFailed, aCompletionStatus.Int());
 
  1616 		}
 
  1623 		}
 
  1617 }
 
  1624 }
 
  1618 
  1625 
  1619 /** Cancels last asynchronous request to eTel
 
  1626 /** Cancels last asynchronous request to eTel
 
  1620 
  1627 
  1621 @param  aContext - pdp context
 
  1628 @param  aContext - pdp context
 
  1622 */
 
  1629 */
 
  1623 void TCreateMbmsPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
  1630 void TCreateMbmsPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)
 
  1624 	{
 
  1631 	{
 
  1625 	SPUDTEL_FNLOG("TCreate1ryPdpContextStrategy::CancelAsyncRequest()");
 
  1632 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_1, "TCreate1ryPdpContextStrategy::CancelAsyncRequest()");
 
  1626 	
  1633 	
  1627 	switch(aContext.StrategyStep())
 
  1634 	switch(aContext.StrategyStep())
 
  1628 		{
 
  1635 		{
 
  1629 		case ESetConfigStep:
 
  1636 		case ESetConfigStep:
 
  1630 			{
 
  1637 			{
 
  1631 			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextSetConfig"));
 
  1638 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_2, "Cancel PacketContext::EPacketContextSetConfig");
 
  1632 			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1639 			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1633 			break;
 
  1640 			break;
 
  1634 			}
 
  1641 			}
 
  1635 			
  1642 			
  1636 		default:
 
  1643 		default:
 
  1637 			// there're NO outstanding async requests
 
  1644 			// there're NO outstanding async requests
 
  1638 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1645 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TCREATEMBMSPDPCONTEXTSTRATEGY_CANCELASYNCREQUEST_3, "ERROR: Incorrect case");
 
  1639 			ASSERT(EFalse);
 
  1646 			ASSERT(EFalse);
 
  1640 			break;
 
  1647 			break;
 
  1641 		}
 
  1648 		}
 
  1642 	}
 
  1649 	}
 
  1643 
  1650 
  1650 @param aContext - pdp context
 
  1657 @param aContext - pdp context
 
  1651 @param aStatus - request status of this step
 
  1658 @param aStatus - request status of this step
 
  1652 */
 
  1659 */
 
  1653 void TActivateMbmsPdpStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1660 void TActivateMbmsPdpStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1654 	{
 
  1661 	{
 
  1655 	SPUDTEL_FNLOG("TActivatePdpStrategy::Next()");
 
  1662 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_NEXT_1, "TActivatePdpStrategy::Next()");
 
  1656 	
  1663 	
  1657 	TInt err = KErrNone;
 
  1664 	TInt err = KErrNone;
 
  1658 	
  1665 	
  1659 	switch(aContext.StrategyStep())
 
  1666 	switch(aContext.StrategyStep())
 
  1660 		{
 
  1667 		{
 
  1693 			break;
 
  1700 			break;
 
  1694 			}
 
  1701 			}
 
  1695 			
  1702 			
  1696 		default:
 
  1703 		default:
 
  1697 			// unexpected
 
  1704 			// unexpected
 
  1698 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));
 
  1705 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_NEXT_2, "ERROR: Incorrect case");
 
  1699 			ASSERT(EFalse);
 
  1706 			ASSERT(EFalse);
 
  1700 			err = KErrNotSupported;
 
  1707 			err = KErrNotSupported;
 
  1701 			break;
 
  1708 			break;
 
  1702 		}
 
  1709 		}
 
  1703 		
  1710 		
  1717 */	
  1724 */	
  1718 void TActivateMbmsPdpStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1725 void TActivateMbmsPdpStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1719 	{
 
  1726 	{
 
  1720 	if(aCompletionStatus == KErrNone)
 
  1727 	if(aCompletionStatus == KErrNone)
 
  1721 		{
 
  1728 		{
 
  1722 		SPUDTELVERBOSE_INFO_LOG(_L("FSM set: DataChannelV2"));
 
  1729 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_NOTIFYFSM_1, "FSM set: DataChannelV2");
 
  1723 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.DataChannelV2());
 
  1730 		aContext.PdpFsmInterface().Set(aContext.Id(), aContext.DataChannelV2());
 
  1724 
  1731 
  1725 
  1732 
  1726 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpActivated"));
 
  1733 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_NOTIFYFSM_2, "Notifying FSM: EPdpActivated");
 
  1727 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivated);
 
  1734 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivated);
 
  1728 		}
 
  1735 		}
 
  1729 	else
 
  1736 	else
 
  1730 		{
 
  1737 		{
 
  1731 		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPdpActivatedFailed"));
 
  1738 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_NOTIFYFSM_3, "Notifying FSM: EPdpActivatedFailed");
 
  1732 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivatedFailed, aCompletionStatus.Int());
 
  1739 		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPdpActivatedFailed, aCompletionStatus.Int());
 
  1733 		}
 
  1740 		}
 
  1734 	}
 
  1741 	}
 
  1735 	
  1742 	
  1736 /** Cancels last asynchronous request to eTel
 
  1743 /** Cancels last asynchronous request to eTel
 
  1742 	switch(aContext.StrategyStep())
 
  1749 	switch(aContext.StrategyStep())
 
  1743 		{
 
  1750 		{
 
  1744 		case EActivateStep:
 
  1751 		case EActivateStep:
 
  1745 			{
 
  1752 			{
 
  1746 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextActivate);
 
  1753 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextActivate);
 
  1747 			SPUDTEL_INFO_LOG(_L("Cancel MbmsPacketContext::EPacketContextActivate"));
 
  1754 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_CANCELASYNCREQUEST_1, "Cancel MbmsPacketContext::EPacketContextActivate");
 
  1748 			break;
 
  1755 			break;
 
  1749 			}
 
  1756 			}
 
  1750 		
  1757 		
  1751 		case EGetConfigStep:
 
  1758 		case EGetConfigStep:
 
  1752 			{
 
  1759 			{
 
  1753 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextGetConfig);
 
  1760 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextGetConfig);
 
  1754 			SPUDTEL_INFO_LOG(_L("Cancel MbmsPacketContext::EPacketContextGetConfig"));
 
  1761 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_CANCELASYNCREQUEST_2, "Cancel MbmsPacketContext::EGetConfigStep");
 
  1755 			break;
 
  1762 			break;
 
  1756 			}
 
  1763 			}
 
  1757 		
  1764 		
  1758 		case EInitialiseContextStep:
 
  1765 		case EInitialiseContextStep:
 
  1759 			{
 
  1766 			{
 
  1760 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextInitialiseContext);	
  1767 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextInitialiseContext);	
  1761 			SPUDTEL_INFO_LOG(_L("Cancel MbmsPacketContext::EPacketContextInitialiseContext"));
 
  1768 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_CANCELASYNCREQUEST_3, "Cancel MbmsPacketContext::EPacketContextInitialiseContext");
 
  1762 			break;
 
  1769 			break;
 
  1763 			}
 
  1770 			}
 
  1764 			
  1771 			
  1765 					
  1772 					
  1766 		default:
 
  1773 		default:
 
  1767 			// unexpected
 
  1774 			// unexpected
 
  1768 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TActivatePdpStrategy::CancelAsyncRequest"));
 
  1775 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TACTIVATEMBMSPDPSTRATEGY_CANCELASYNCREQUEST_4, "ERROR: Incorrect case in TActivatePdpStrategy::CancelAsyncRequest");
 
  1769 			ASSERT(EFalse);
 
  1776 			ASSERT(EFalse);
 
  1770 			break;
 
  1777 			break;
 
  1771 		}
 
  1778 		}
 
  1772 	}
 
  1779 	}
 
  1773 	
  1780 	
  1779 @param aContext - pdp context
 
  1786 @param aContext - pdp context
 
  1780 @param aStatus - request status of this step
 
  1787 @param aStatus - request status of this step
 
  1781 */	
  1788 */	
  1782 void TMbmsSessionUpdateStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1789 void TMbmsSessionUpdateStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)
 
  1783 	{
 
  1790 	{
 
  1784 	SPUDTEL_FNLOG("TMbmsSessionUpdateStrategy::Next()");
 
  1791 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_NEXT_1, "TMbmsSessionUpdateStrategy::Next()");
 
  1785 	
  1792 	
  1786 	TInt err = KErrNone;
 
  1793 	TInt err = KErrNone;
 
  1787 	switch(aContext.StrategyStep())
 
  1794 	switch(aContext.StrategyStep())
 
  1788 		{
 
  1795 		{
 
  1789 		case EStartStep:
 
  1796 		case EStartStep:
 
  1887 */		
  1894 */		
  1888 void TMbmsSessionUpdateStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1895 void TMbmsSessionUpdateStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )
 
  1889 	{
 
  1896 	{
 
  1890 		if(aCompletionStatus == KErrNone)
 
  1897 		if(aCompletionStatus == KErrNone)
 
  1891 		{
 
  1898 		{
 
  1892 		SPUDTEL_INFO_LOG(_L("Notifying FSM: TMbmsSessionUpdateStrategy"));
 
  1899 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_NOTIFYFSM_1, "Notifying FSM: TMbmsSessionUpdateStrategy");
 
  1893 		aContext.PdpFsmInterface().Input(aContext.Id(), SpudMan::EMbmsParameterUpdate);
 
  1900 		aContext.PdpFsmInterface().Input(aContext.Id(), SpudMan::EMbmsParameterUpdate);
 
  1894 		}
 
  1901 		}
 
  1895 	else
 
  1902 	else
 
  1896 		{
 
  1903 		{
 
  1897 		SPUDTEL_INFO_LOG(_L("Notifying FSM: TMbmsSessionUpdateStrategy"));
 
  1904 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_NOTIFYFSM_2, "Notifying FSM: TMbmsSessionUpdateStrategy");
 
  1898 		aContext.PdpFsmInterface().Input(aContext.Id(), SpudMan::EMbmsParameterUpdate, aCompletionStatus.Int());
 
  1905 		aContext.PdpFsmInterface().Input(aContext.Id(), SpudMan::EMbmsParameterUpdate, aCompletionStatus.Int());
 
  1899 		}
 
  1906 		}
 
  1900 	}
 
  1907 	}
 
  1901 /** Cancels last asynchronous request to eTel
 
  1908 /** Cancels last asynchronous request to eTel
 
  1902 
  1909 
  1908 	switch(aContext.StrategyStep())
 
  1915 	switch(aContext.StrategyStep())
 
  1909 		{
 
  1916 		{
 
  1910 		case EUpdateMbmsSessionList:
 
  1917 		case EUpdateMbmsSessionList:
 
  1911 			{
 
  1918 			{
 
  1912 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1919 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1913 			SPUDTEL_INFO_LOG(_L("Cancel MbmsPacketContext::EUpdateMbmsSessionList"));
 
  1920 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_CANCELASYNCREQUEST_1, "Cancel MbmsPacketContext::EUpdateMbmsSessionList");
 
  1914 			break;
 
  1921 			break;
 
  1915 			}
 
  1922 			}
 
  1916 		
  1923 		
  1917 		case EPrepareSessionList:
 
  1924 		case EPrepareSessionList:
 
  1918 			{
 
  1925 			{
 
  1919 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1926 			aContext.MbmsPacketContext().CancelAsyncRequest(EPacketContextSetConfig);
 
  1920 			SPUDTEL_INFO_LOG(_L("Cancel MbmsPacketContext::EPrepareSessionList"));
 
  1927 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_CANCELASYNCREQUEST_2, "Cancel MbmsPacketContext::EPrepareSessionList");
 
  1921 			break;
 
  1928 			break;
 
  1922 			}
 
  1929 			}
 
  1923 								
  1930 								
  1924 		default:
 
  1931 		default:
 
  1925 			// unexpected
 
  1932 			// unexpected
 
  1926 			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TMbmsSessionUpdateStrategy::CancelAsyncRequest"));
 
  1933 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TMBMSSESSIONUPDATESTRATEGY_CANCELASYNCREQUEST_3, "ERROR: Incorrect case in TMbmsSessionUpdateStrategy::CancelAsyncRequest");
 
  1927 			ASSERT(EFalse);
 
  1934 			ASSERT(EFalse);
 
  1928 			break;
 
  1935 			break;
 
  1929 		}
 
  1936 		}
 
  1930 	
  1937 	
  1931 	}
 
  1938 	}
FCL/sf/os/cellularsrv