// Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// A collection of etel driver strategies

// 

//

/**

 @file 

 @internalComponent

*/

#include <e32def.h>

#include "ceteldrivercontext.h"

#include "eteldriverstrategies.h"

#include "pdpfsmnmspace.h"

#include <pcktcs.h>

using namespace ConnectionServ;

//

//	TOpenStrategy

//

/** Executes next asynchronous step in a strategy. 

@param aContext - pdp context

@param aStatus - request status of this step

*/

void TOpenStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)

	{

	TInt err = KErrNone;

	switch(aContext.StrategyStep())

		{

		case EStartStep:

			{

			aContext.Phone().Initialise (*aStatus);

			aContext.SetStrategyStep(EInitPhoneStep);

			break;

			}

		case EInitPhoneStep:

			{

			aContext.SetStrategyStep(EFinishStep);

			break;

			}

		default:

			// incorrect step

			ASSERT(EFalse);

			err = KErrNotSupported;

			break;

		} // switch

	if(err || (EFinishStep == aContext.StrategyStep()))

		{

		User::RequestComplete( aStatus, err);

		}

	}

/** 

Notifies SPUD FSM about execution results.

@param aContext - pdp context

@param aCompletionStatus - completion request status

*/	

void TOpenStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)

	{

	if(aCompletionStatus == KErrNone)

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpened);

		}

	else

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EPhoneOpenedFailed, aCompletionStatus.Int());

		}

	}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TOpenStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)

	{

	switch(aContext.StrategyStep())

		{

		case EInitPhoneStep:

			{

			aContext.Phone().InitialiseCancel();

			break;

			}

		default:

			// there're NO outstanding async requests

			ASSERT(EFalse);

			break;

		}

	}

//

//	TContextDeleteStrategy

//

/** Executes next asynchronous step in a strategy. 

@param aContext - pdp context

@param aStatus - request status of this step

*/

void TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)

	{

	TInt err = KErrNone;

	// steps:

	//	-- cancel notifications

	//	-- deactivate context

	//	-- close QoS only for Primary & secondary, for MBMS just skip

	//	-- close context

	// 	-- delete context

	switch(aContext.StrategyStep())

		{

		case EStartStep:

			{

			// cancel associated notifications

			// -- 	StatusChangeNotifier

			// --	QoSChangeNotifier

			// --	ConfigChangeNotifier

			aContext.StopNotifications();

			if (aContext.ContextType() != SpudMan::EMbms)

				{

				if (aContext.PacketContext().SubSessionHandle())

					{

					aContext.PacketContext().Deactivate(*aStatus);

					aContext.SetStrategyStep (EDeactivateStep);

					}

				else

					{

					aContext.SetStrategyStep(EDeactivateStep);

					User::RequestComplete(aStatus, err);

					}

				}

			else

				{

				if (aContext.MbmsPacketContext().SubSessionHandle())

					{

					aContext.MbmsPacketContext().Deactivate(*aStatus);

					aContext.SetStrategyStep (EDeactivateStep);

					}

				else

					{

					aContext.SetStrategyStep(EDeleteContextStep);

					User::RequestComplete(aStatus, err);

					}	

				}	

			break;

			}

		case EDeactivateStep:

			{

			if (aContext.ContextType() != SpudMan::EMbms)

				{

				if (aContext.PacketQoS().SubSessionHandle())

					{

					aContext.PacketQoS().Close();

					}

				if (aContext.PacketContext().SubSessionHandle())

					{

					aContext.PacketContext().Delete(*aStatus);

					aContext.SetStrategyStep(EDeleteContextStep);

					}

				else

					{

					// jump to next step

					aContext.SetStrategyStep(EDeleteContextStep);

					User::RequestComplete( aStatus, err);

					}

				}

			else

				{

				if (aContext.MbmsPacketContext().SubSessionHandle())

					{

					aContext.MbmsPacketContext().Delete(*aStatus);

					aContext.SetStrategyStep(EDeleteContextStep);

					}

				else

					{

					// jump to next step

					aContext.SetStrategyStep(EDeleteContextStep);

					User::RequestComplete( aStatus, err);

					}	

				}	

			break;

			}

		case EDeleteContextStep:

			{

			if (aContext.ContextType() != SpudMan::EMbms)

				{

				aContext.PacketContext().Close();

				}

			else

				{

				aContext.MbmsPacketContext().Close();

				}	

			// clear the name

			aContext.Name().Zero();

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			// incorrect step

			ASSERT(EFalse);

			err = KErrNotSupported;

			break;

		} // switch

	if(err || (EFinishStep == aContext.StrategyStep()))

		{

		User::RequestComplete( aStatus, err);

		}

	}

/** 

Notifies SPUD FSM about execution results.

@param aContext - pdp context

@param aCompletionStatus - completion request status

*/	

void TContextDeleteStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)

	{

	aContext.PdpFsmInterface().Set(aContext.Id(), RPacketContext::EStatusDeleted);

	if(aCompletionStatus == KErrNone)

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeleted);

		}

	else

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::EContextDeletedFailed, aCompletionStatus.Int());

		}

	}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TContextDeleteStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)

	{

	// When there is no sub-session, the strategy will not call DeactivateContext, but will be in the EDeactivateStep state

	// In this case we don't want to cancel the deactivate request

	if (aContext.iStatus != KRequestPending)

		{

		return;

		}

	switch(aContext.StrategyStep())

		{

		case EDeactivateStep:

			{

			aContext.PacketContext().CancelAsyncRequest(EPacketContextDeactivate);

			break;

			}

		case EDeleteContextStep:

			{

			aContext.PacketContext().CancelAsyncRequest(EPacketContextDelete);

			break;

			}

		default:

			// there're NO outstanding async requests

			ASSERT(EFalse);

			break;

		}

	}

// 

//	TCreate1ryPdpContextStrategy 

//

/** Executes next asynchronous step in a strategy. 

@param aContext - pdp context

@param aStatus - request status of this step

*/

void TCreate1ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)

	{

	TInt err = KErrNone;

	// possible steps:

	// 	-- open new context

	//	-- open new QoS

	// 	-- initialise context

	switch(aContext.StrategyStep())

		{

		case EStartStep:

			{

			err = aContext.PacketContext().OpenNewContext (aContext.PacketService(), aContext.Name());

			if (err)

				{

				break;

				}

			aContext.PacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						

			aContext.SetStrategyStep (EInitialiseContextStep);

			break;

			}

		case EInitialiseContextStep:

			{

			// get packet config from fsm

			aContext.PdpFsmInterface().Get (aContext.Id(), aContext.ContextPacketDataConfigBase());

			// async set config

			aContext.PacketContext().SetConfig (*aStatus, aContext.ContextConfig());

			// set next step

			aContext.SetStrategyStep (ESetConfigStep);

			break;

			}

		case ESetConfigStep:

			{

			// QoS name is not used anywhere

			TName newName;

			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);

			if (err)

				{ 

				break; 

				}

#ifdef SYMBIAN_NETWORKING_UMTSR5

            RPacketQoS::TQoSR5Requested r5;

            aContext.PdpFsmInterface().Get (aContext.Id(), r5);

			aContext.QosRequested() = r5;

#else

            RPacketQoS::TQoSR99_R4Requested r4;

			aContext.PdpFsmInterface().Get (aContext.Id(), r4);

			aContext.QosRequested() = r4;

#endif 

// SYMBIAN_NETWORKING_UMTSR5

            aContext.DumpReqProfileParameters ();

#endif			

			aContext.PacketQoS().SetProfileParameters (*aStatus, aContext.QosRequestedPckg());

			aContext.SetStrategyStep (ESetProfileParamsStep);

			break;

			}

		case ESetProfileParamsStep:

			{

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			ASSERT(EFalse);

			err = KErrNotSupported;

			break;

		}

	if(err || (EFinishStep == aContext.StrategyStep()))

		{

		User::RequestComplete( aStatus, err);

		}

	}

/** 

Notifies SPUD FSM about execution results.

@param aContext - pdp context

@param aCompletionStatus - completion request status

*/	

void TCreate1ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus)

{

	if(aCompletionStatus == KErrNone)

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreated);

		}

	else

		{

		aContext.PdpFsmInterface().Input(aContext.Id(), PdpFsm::E1ryPdpContextCreatedFailed, aCompletionStatus.Int());

		}

}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TCreate1ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)

	{

	switch(aContext.StrategyStep())

		{

		case ESetConfigStep:

			{

			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);

			break;

			}

		case ESetProfileParamsStep:

			{

			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);

			break;

			}

		case EInitialiseContextStep:

		    aContext.PacketContext().CancelAsyncRequest(EPacketContextInitialiseContext);

		    break;

		default:

			// there're NO outstanding async requests

			ASSERT(EFalse);

			break;

		}

	}

// 

//	TCreate2ryPdpContextStrategy 

//

/** Executes next asynchronous step in a strategy. 

@param aContext - pdp context

@param aStatus - request status of this step

*/

void TCreate2ryPdpContextStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)

	{

	TInt err = KErrNone;

	// possible steps:

	//	-- open new secondary context

	//	-- open new QoS

	//	-- initialise context

	switch(aContext.StrategyStep())

		{

		case EStartStep:

			{

			const TName& existingContextName = aContext.ExistingContextName();

			aContext.PacketContext().OpenNewSecondaryContext(aContext.PacketService(), existingContextName, aContext.Name());

			aContext.PacketContext().InitialiseContext(*aStatus, aContext.DataChannelV2Pckg());						

			aContext.SetStrategyStep (EInitialiseContextStep);

			break;

			}

		case EInitialiseContextStep:

			{

			// QoS name is not used anywhere

			TName newName;

			err = aContext.PacketQoS().OpenNewQoS (aContext.PacketContext(), newName);

			if (err)

				{ 

				break; 

				}

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			ASSERT(EFalse);

			err = KErrNotSupported;