// Copyright (c) 2004-2009 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 "spudteldebuglogger.h"

#include "pdpfsmnmspace.h"

#include <pcktcs.h>

//

//	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)

	{

	SPUDTEL_FNLOG("TOpenStrategy::Next()");

	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

			SPUDTEL_ERROR_LOG0(_L("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)

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPhoneOpened"));

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

		}

	else

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: EPhoneOpenedFailed"));

		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:

			{

			SPUDTEL_INFO_LOG(_L("Cancel Phone::InitialiseCancel"));

			aContext.Phone().InitialiseCancel();

			break;

			}

		default:

			// there're NO outstanding async requests

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case in TOpenStrategy::CancelAsyncRequest"));

			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)

	{

	SPUDTEL_FNLOG("TContextDeleteStrategy::Next(CEtelDriverContext& aContext, TRequestStatus* aStatus)");

	TInt err = KErrNone;

	// steps:

	//	-- cancel notifications

	//	-- deactivate context

	//	-- close QoS

	//	-- close context

	// 	-- delete context

	switch(aContext.StrategyStep())

		{

		case EStartStep:

			{

			// cancel associated notifications

			// -- 	StatusChangeNotifier

			// --	QoSChangeNotifier

			// --	ConfigChangeNotifier

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

				{

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

				aContext.SetStrategyStep (EDeactivateStep);

				}

			else

				{

				aContext.SetStrategyStep(EDeactivateStep);

				User::RequestComplete(aStatus, err);

				}

			break;

			}

		case EDeactivateStep:

			{

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

				{

                aContext.QoSChangeNotifierCancel();

				aContext.PacketQoS().Close();

				}

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

				{

                aContext.PdpConfigChangeNotifierCancel();

                aContext.PdpStatusChangeNotifierCancel();

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

				aContext.SetStrategyStep(EDeleteContextStep);

				}

			else

				{

				// jump to next step

				aContext.SetStrategyStep(EDeleteContextStep);

				User::RequestComplete( aStatus, err);

				}

			break;

			}

		case EDeleteContextStep:

			{

			aContext.PacketContext().Close();

			// clear the name

			aContext.Name().Zero();

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			// incorrect step

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));

			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)

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: EContextDeleted"));

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

		}

	else

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: EContextDeletedFailed"));

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

		}

	}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TContextDeleteStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)

	{

	SPUDTEL_FNLOG("TContextDeleteStrategy::CancelAsyncRequest()");

	// 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:

			{

			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextDeactivate"));

			aContext.PacketContext().CancelAsyncRequest(EPacketContextDeactivate);

			break;

			}

		case EDeleteContextStep:

			{

			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextDelete"));

			aContext.PacketContext().CancelAsyncRequest(EPacketContextDelete);

			break;

			}

		default:

			// there're NO outstanding async requests

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));

			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)

	{

	SPUDTEL_FNLOG("TCreate1ryPdpContextStrategy::Next()");

	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)

				{

				SPUDTEL_ERROR_LOG(_L("PacketContextOpenNewContext returned %d"), err);

				break;

				}

			// get packet config from fsm

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

			// async set config

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

			// 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)

				{ 

				SPUDTEL_ERROR_LOG(_L("PacketQoS OpenNewQoS returned %d"), 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

#ifdef _DEBUG

            aContext.DumpReqProfileParameters ();

#endif			

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

			aContext.SetStrategyStep (ESetProfileParamsStep);

			break;

			}

		case ESetProfileParamsStep:

			{

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));

			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)

		{

		// start notifications in case of normal creation of a context

		// -- 	StatusChangeNotifier

		// --	QoSChangeNotifier

		// --	ConfigChangeNotifier

		aContext.StartNotifications();

		SPUDTEL_INFO_LOG(_L("Notifying FSM: E1ryPdpContextCreated"));

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

		}

	else

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: E1ryPdpContextCreatedFailed"));

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

		}

}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TCreate1ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& aContext)

	{

	SPUDTEL_FNLOG("TCreate1ryPdpContextStrategy::CancelAsyncRequest()");

	switch(aContext.StrategyStep())

		{

		case ESetConfigStep:

			{

			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketContextSetConfig"));

			aContext.PacketContext().CancelAsyncRequest(EPacketContextSetConfig);

			break;

			}

		case ESetProfileParamsStep:

			{

			SPUDTEL_INFO_LOG(_L("Cancel PacketContext::EPacketQoSSetProfileParams"));

			aContext.PacketQoS().CancelAsyncRequest(EPacketQoSSetProfileParams);

			break;

			}

		default:

			// there're NO outstanding async requests

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));

			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)

	{

	SPUDTEL_FNLOG("TCreate2ryPdpContextStrategy::Next()");

	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());

			// QoS name is not used anywhere

			TName newName;

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

			if (err)

				{ 

				SPUDTEL_ERROR_LOG(_L("PacketQoS OpenNewQoS returned %d"), err);

				break; 

				}

			aContext.SetStrategyStep (EFinishStep);

			break;

			}

		default:

			SPUDTEL_ERROR_LOG0(_L("ERROR: Incorrect case"));

			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 TCreate2ryPdpContextStrategy::NotifyFsm(CEtelDriverContext& aContext, TRequestStatus& aCompletionStatus )

{

	if(aCompletionStatus == KErrNone)

		{

		// start notifications in case of normal creation of a context

		// -- 	StatusChangeNotifier

		// --	QoSChangeNotifier

		// --	ConfigChangeNotifier

		aContext.StartNotifications();

		SPUDTEL_INFO_LOG(_L("Notifying FSM: E2ryPdpContextCreated"));

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

		}

	else

		{

		SPUDTEL_INFO_LOG(_L("Notifying FSM: E2ryPdpContextCreatedFailed"));

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

		}

}

/** Cancels last asynchronous request to eTel

@param  aContext - pdp context

*/

void TCreate2ryPdpContextStrategy::CancelAsyncRequest(CEtelDriverContext& /*aContext*/)

	{

	SPUDTEL_FNLOG("TCreate2ryPdpContextStrategy::CancelAsyncRequest()");

	SPUDTEL_ERROR_LOG0(_L("ERROR: No outstanding requests"));

	}

//

// TSetQoSStrategy

//

/** Executes next asynchronous step in a strategy. 

@param aContext - pdp context

@param aStatus - request status of this step

*/

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

	{

	SPUDTEL_FNLOG("TSetQoSStrategy::Next()");

	TInt err = KErrNone;