// TestTelephonyPktTestStepBase.cpp

// Copyright (c) Symbian Software Ltd 2008. All rights reserved.

//

// Implementation of the Class CTestTelephonyPktTestStepBase

// 	user include

#include "TestLtsyPktTestStepBase.h"

#include "te_integration_stltsysuitestepbase.h"

#include "te_integration_stltsysuitedefs.h"

_LIT8(KName, "internet");

/**

 * Constructor

 */

CTestLtsyPktTestStepBase::CTestLtsyPktTestStepBase(CTestLtsyModel& aModel)

	:iModel(aModel),iSharedPhone(aModel.SharedEnv().Phone())

	{

	}

/**

 * Destructor

 * 

 */

CTestLtsyPktTestStepBase::~CTestLtsyPktTestStepBase()

	{

	}

TVerdict CTestLtsyPktTestStepBase::doTestStepPreambleL()

	{

	INFO_PRINTF1(_L("CTestLtsyPktTestStepBase::doTestStepPreambleL()."));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CTestLtsyPktTestStepBase::doTestStepPostambleL()

	{

	INFO_PRINTF1(_L("CTestLtsyPktTestStepBase::doTestStepPostambleL()"));

	return TestStepResult();

	}

/**

 * Get the shared phone

 * 

 */

RMobilePhone& CTestLtsyPktTestStepBase::SharedPhone() 

	{

	return iSharedPhone;

	}

/**

 * Check if the RPacketService has been opened

 * @return - the result

 */

TBool CTestLtsyPktTestStepBase::IsOpenedPktService()

	{

	return (NULL != iModel.PktSharedData().iPacket.SubSessionHandle());

	}

void CTestLtsyPktTestStepBase::OpenPacketobject()

	{

	TInt           returnStatus;

	INFO_PRINTF1(_L("Close packet\n"));

	// Open Packet object

	iModel.PktSharedData().iPacket.Close();

	INFO_PRINTF1(_L("packet closeed \n"));

	INFO_PRINTF1(_L("To open Packet Object\n"));

	returnStatus = iModel.PktSharedData().iPacket.Open(iModel.SharedEnv().Phone());

	if(returnStatus == KErrNone)

		{

		INFO_PRINTF1(_L("packet opened \n"));

		}

	else

		{

		INFO_PRINTF1(_L("Opened packet error\n"));

		INFO_PRINTF2(_L("Opened packet error = %d\n"), returnStatus);

		}

	}

void CTestLtsyPktTestStepBase::ClosePacketobject()

	{

	INFO_PRINTF1(_L("Close packet\n"));

	User::After(1000000);

	iModel.PktSharedData().iPacket.Close();

	INFO_PRINTF1(_L("packet closeed \n"));

	}

void CTestLtsyPktTestStepBase::DisplayPacketServiceStatus()

/**

 * Test the TSY's functionality to retrieve the packet service status.

 */

	{

	TInt returnStatus = iModel.PktSharedData().iPacket.GetStatus(iModel.PktSharedData().iPacketStatus);

	if(returnStatus==KErrNone)

		{

		switch (iModel.PktSharedData().iPacketStatus)

			{

			case RPacketService::EStatusUnattached:

				INFO_PRINTF1(_L("Packet Service status = Unattached\n"));

				break;

			case RPacketService::EStatusAttached:

				INFO_PRINTF1(_L("Packet Service status = Attached\n"));

				break;

			case RPacketService::EStatusActive:

				INFO_PRINTF1(_L("Packet Service status = Active\n"));

				break;

			case RPacketService::EStatusSuspended:

				INFO_PRINTF1(_L("Packet Service status = Suspended\n"));

				break;

			default:

				INFO_PRINTF1(_L("Packet Service error\n"));

				break;

			}

		}

	else

		{

		INFO_PRINTF1(_L("Packet Service error\n"));

		}

	}

void CTestLtsyPktTestStepBase::GprsNetWorkTest()

	{

	INFO_PRINTF1(_L("Open Packet Object"));

	TInt           returnStatus;

	TRequestStatus requestStatus;

	INFO_PRINTF1(_L("Close packet\n"));

	// Open Packet object

	iModel.PktSharedData().iPacket.Close();

	INFO_PRINTF1(_L("packet closeed \n"));

	INFO_PRINTF1(_L("To open Packet Object\n"));

	returnStatus = iModel.PktSharedData().iPacket.Open(iSharedPhone);

	if(returnStatus == KErrNone)

		{

		INFO_PRINTF1(_L("packet opened \n"));

		}

	else

		{

		INFO_PRINTF1(_L("Opened packet error\n"));

		}

	requestStatus = KErrNone;

	INFO_PRINTF1((_L("RPacket::GetNtwkRegStatus() invoked...\n")));

	iModel.PktSharedData().iPacket.GetNtwkRegStatus(requestStatus, iModel.PktSharedData().iRegistrationStatus);

	User::WaitForRequest(requestStatus);

	if(requestStatus == KErrNone)

		{

		switch (iModel.PktSharedData().iRegistrationStatus)

			{

			case RPacketService::ENotRegisteredNotSearching:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered Not Searching\n"));

				break;

			case RPacketService::ERegisteredOnHomeNetwork:

				INFO_PRINTF1(_L("Netw Reg status = Registered On Home Network\n"));

				break;

			case RPacketService::ENotRegisteredSearching:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered Searching\n"));

				break;

			case RPacketService::ERegistrationDenied:

				INFO_PRINTF1(_L("Netw Reg status = Registration Denied\n"));

				break;

			case RPacketService::EUnknown:

				INFO_PRINTF1(_L("Netw Reg status = Unknown\n"));

				break;

			case RPacketService::ERegisteredRoaming:

				INFO_PRINTF1(_L("Netw Reg status = RegisteredRoaming\n"));

				break;

			case RPacketService::ENotRegisteredButAvailable:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered But Available\n"));

				break;

			case RPacketService::ENotRegisteredAndNotAvailable:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered And Not Available\n"));

				break;

			default:

				INFO_PRINTF1(_L("Network Registration Status Error\n"));

				break;

			}

		}

	else

		{

		INFO_PRINTF1(_L("Network Registration Status Error\n"));

		}

	iModel.PktSharedData().iPacket.Close();

	}

void CTestLtsyPktTestStepBase::DisplayNetworkRegistrationStatus()

/**

 * Test the TSY's functionality to retrieve the network registration status.

 */

	{

	TRequestStatus requestStatus = KErrNone;

	INFO_PRINTF1((_L("RPacket::GetNtwkRegStatus() invoked...\n")));

	iModel.PktSharedData().iPacket.GetNtwkRegStatus(requestStatus, iModel.PktSharedData().iRegistrationStatus);

	User::WaitForRequest(requestStatus);

	if(requestStatus == KErrNone)

		{

		switch (iModel.PktSharedData().iRegistrationStatus)

			{

			case RPacketService::ENotRegisteredNotSearching:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered Not Searching\n"));

				break;

			case RPacketService::ERegisteredOnHomeNetwork:

				INFO_PRINTF1(_L("Netw Reg status = Registered On Home Network\n"));

				break;

			case RPacketService::ENotRegisteredSearching:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered Searching\n"));

				break;

			case RPacketService::ERegistrationDenied:

				INFO_PRINTF1(_L("Netw Reg status = Registration Denied\n"));

				break;

			case RPacketService::EUnknown:

				INFO_PRINTF1(_L("Netw Reg status = Unknown\n"));

				break;

			case RPacketService::ERegisteredRoaming:

				INFO_PRINTF1(_L("Netw Reg status = RegisteredRoaming\n"));

				break;

			case RPacketService::ENotRegisteredButAvailable:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered But Available\n"));

				break;

			case RPacketService::ENotRegisteredAndNotAvailable:

				INFO_PRINTF1(_L("Netw Reg status = Not Registered And Not Available\n"));

				break;

			default:

				INFO_PRINTF1(_L("Network Registration Status Error\n"));

				break;

			}

		}

	else

		{

		INFO_PRINTF1(_L("Network Registration Status Error\n"));

		}

	}

void CTestLtsyPktTestStepBase::DisplayContextInfo()

/**

 * Test the TSY's functionality to retrieve the packet context information

 * using the packet service object.

 */

	{

	// Enumerate Contexts & Get Context Info

	INFO_PRINTF1(_L("Display the packet context information\n"));

	TRequestStatus requestStatus = KErrNone;

	INFO_PRINTF1(_L("RPacketService::EnumerateContexts() invoked....\n"));

	iModel.PktSharedData().iPacket.EnumerateContexts(requestStatus, iModel.PktSharedData().iNumContexts, iModel.PktSharedData().iMaxContextsAllowed);

	User::WaitForRequest(requestStatus);

	INFO_PRINTF2(_L("RPacketService::EnumerateContexts() completed %d\n"), requestStatus.Int());

	INFO_PRINTF2(_L("Number of Contexts   = %d\n"), iModel.PktSharedData().iNumContexts);

	INFO_PRINTF2(_L("Max Contexts Allowed = %d\n"), iModel.PktSharedData().iMaxContextsAllowed);

	requestStatus = KErrNone;

	INFO_PRINTF1(_L("Sync RPacket::GetContextInfo() invoked...\n"));

	iModel.PktSharedData().iPacket.GetContextInfo(requestStatus, 0, iModel.PktSharedData().iContextInfo);

	User::WaitForRequest(requestStatus);

	INFO_PRINTF2(_L("Sync RPacket::GetContextInfo() completed %d\n"), requestStatus.Int());

	if (requestStatus == KErrNone)

		{

		INFO_PRINTF2(_L("Context Name   = %S\n"), &iModel.PktSharedData().iContextInfo.iName);

		DisplayContextStatus(iModel.PktSharedData().iContextInfo.iStatus);

		}

/********************************************************************

	console->Printf(TRefByValue<const TDesC>(_L("Execute Async RPacket::GetContextInfo()\n")));

	TRequestStatus requestStatus;

	iPacket.GetContextInfo(requestStatus, 0, iContextInfo2);

	User::WaitForRequest(requestStatus);

	console->Printf(TRefByValue<const TDesC>(_L("RPacketService::GetContextInfo() ret = %d\n")), requestStatus);

	if (requestStatus == KErrNone)

		{

		console->Printf(TRefByValue<const TDesC>(_L("Context Name   = %S\n")), iContextInfo2.iName);

		console->Printf(TRefByValue<const TDesC>(_L("Context Status = %d\n")), iContextInfo2.iStatus);

		}

*********************************************************************/

	}

void CTestLtsyPktTestStepBase::DisplayContextStatus(RPacketContext::TContextStatus aContextStatus)

	{

	switch (aContextStatus)

		{

		case RPacketContext::EStatusUnknown:

			INFO_PRINTF1(_L("Context Status = Unknown\n"));

			break;

		case RPacketContext::EStatusInactive:

			INFO_PRINTF1(_L("Context Status = Inactive\n"));

			break;

		case RPacketContext::EStatusActivating:

			INFO_PRINTF1(_L("Context Status = Activating\n"));

			break;

		case RPacketContext::EStatusActive:

			INFO_PRINTF1(_L("Context Status = Active\n"));

			break;

		case RPacketContext::EStatusDeactivating:

			INFO_PRINTF1(_L("Context Status = Deactivating\n"));

			break;

		case RPacketContext::EStatusSuspended:

			INFO_PRINTF1(_L("Context Status = Suspended\n"));

			break;

		case RPacketContext::EStatusDeleted:

			INFO_PRINTF1(_L("Context Status = Deleted\n"));

			break;

		default:

			INFO_PRINTF1(_L("Error - Context Status\n"));

			break;

		}

	}

void CTestLtsyPktTestStepBase::DisplayContextStatus(RPacketContext& aContext, RPacketContext::TContextStatus& aContextStatus)

	{

	TRequestStatus returnStatus = aContext.GetStatus(aContextStatus);

	if(returnStatus == KErrNone)

		{

		INFO_PRINTF1(_L("RPacketContext::GetStatus() OK\n"));

		}

	else

		{

		INFO_PRINTF1(_L("Error - Context Status\n"));

		}

	DisplayContextStatus(aContextStatus);

	}

void  CTestLtsyPktTestStepBase::GprsContextAttachTest()

	{

	INFO_PRINTF1(_L("GprsContextAttachTest\n"));

	TRequestStatus requestStatus = KErrNone;

	iModel.PktSharedData().iPacket.Attach(requestStatus);

	User::WaitForRequest(requestStatus);

	if(requestStatus == KErrNone)

		{

		INFO_PRINTF1(_L("GprsContextAttachTest OK \n"));

		}

	else

		{

		INFO_PRINTF1(_L("GprsContextAttachTest Error\n"));

		INFO_PRINTF2(_L("GprsContextAttachTest Error = %d\n"), requestStatus.Int());

		}

	}

void  CTestLtsyPktTestStepBase::GprsContextDetachTest()

	{

	INFO_PRINTF1(_L("GprsContextDetachTest\n"));

	TRequestStatus requestStatus = KErrNone;

	iModel.PktSharedData().iPacket.Detach(requestStatus);

	User::WaitForRequest(requestStatus);

	if(requestStatus == KErrNone)

		{

		INFO_PRINTF1(_L("GprsContextDetachTest OK \n"));

		}

	else

		{

		INFO_PRINTF1(_L("GprsContextDetachTest Error\n"));

		INFO_PRINTF2(_L("GprsContextDetachTest Error = %d\n"), requestStatus.Int());

		}

	}

void  CTestLtsyPktTestStepBase::DisplayStaticCapabilities()

	{

	// Static Capabilities

	TRequestStatus returnStatus = KErrNone;

	returnStatus = iModel.PktSharedData().iPacket.GetStaticCaps(iModel.PktSharedData().iStaticCaps, RPacketContext::EPdpTypeCDPD);

	INFO_PRINTF2(_L("RPacketService::GetStaticCaps() ret = %d\n"), returnStatus.Int());

	INFO_PRINTF2(_L("Static Caps = %d\n"), iModel.PktSharedData().iStaticCaps);

	INFO_PRINTF2(_L("Static Caps = %xH\n"), iModel.PktSharedData().iStaticCaps);

	}

void  CTestLtsyPktTestStepBase::DisplayDynamicCapabilities()

	{

	// Dynamic Capabilities

	TRequestStatus returnStatus = KErrNone;

	returnStatus = iModel.PktSharedData().iPacket.GetDynamicCaps(iModel.PktSharedData().iDynamicCaps);

	INFO_PRINTF2(_L("RPacketService::GetDynamicCaps() ret = %d\n"), returnStatus.Int());

	INFO_PRINTF2(_L("Dynamic Caps = %d\n"), iModel.PktSharedData().iDynamicCaps);

	INFO_PRINTF2(_L("Dynamic Caps = %xH\n"), iModel.PktSharedData().iDynamicCaps);

	}

void  CTestLtsyPktTestStepBase::GprsGetDefaultContextParamsTest()

	{

	TRequestStatus reqStatusContextParams = KErrNone;

	RPacketContext::TContextConfigGPRS contextConfig01;

	TPckg<RPacketContext::TContextConfigGPRS> contextConfigPckg01(contextConfig01);

	INFO_PRINTF1(_L("RPacketContext::GetDefaultContextParams() invoked...\n"));

	iModel.PktSharedData().iPacket.GetDefaultContextParams(reqStatusContextParams, contextConfigPckg01);

	User::WaitForRequest(reqStatusContextParams);

	if(reqStatusContextParams == KErrNone)

		{

		INFO_PRINTF1(_L("RPacketContext::GetDefaultContextParams() complete\n"));

		}

	else

		{

		INFO_PRINTF1(_L("RPacketContext::GetDefaultContextParams() Error\n"));

		INFO_PRINTF2(_L("RPacketService::GprsgetDefaultContextParamsTest() completed %d\n"), reqStatusContextParams.Int());

		}

	}

void  CTestLtsyPktTestStepBase::GprsSetDefaultContextParamsTest()

	{

	// Set Context Config

	TRequestStatus reqStatusContextParams = KErrNone;

	RPacketContext::TContextConfigGPRS contextConfig02;

	//contextConfig2.iServiceOption = RPacketContext::KLowSpeedData;

	contextConfig02.iPdpType  = RPacketContext::EPdpTypeIPv6;

	TPckg<RPacketContext::TContextConfigGPRS> contextConfigPckg02(contextConfig02);

	INFO_PRINTF1(_L("RPacketContext::SetDefaultContextParams() invoked...\n"));

	iModel.PktSharedData().iPacket.SetDefaultContextParams(reqStatusContextParams, contextConfigPckg02);

	User::WaitForRequest(reqStatusContextParams);

	if(reqStatusContextParams == KErrNone)

		{

		INFO_PRINTF1(_L("RPacketContext::GprsContextSetConfigTest() complete\n"));

		}

	else

		{

		INFO_PRINTF1(_L("RPacketContext::GprsContextSetConfigTest() Error\n"));

		INFO_PRINTF2(_L("RPacketService::GprsSetDefaultContextParamsTest() completed %d\n"), reqStatusContextParams.Int());

		}

	}

void  CTestLtsyPktTestStepBase::GprsContextActivateTest()

	{

	TRequestStatus requestStatus = KErrNone;

	INFO_PRINTF1(_L("RPacketContext::Activate() invoked...\n"));

	iModel.PktSharedData().iContext1.Activate(requestStatus);

	User::WaitForRequest(requestStatus);

	INFO_PRINTF2(_L("RPacketContext::Activate() completed %d\n"), requestStatus.Int());

	}

void  CTestLtsyPktTestStepBase::GprsContextDeactivateTest()

	{

	TRequestStatus requestStatus = KErrNone;

	INFO_PRINTF1(_L("RPacketContext::Deactivate() invoked...\n"));

	iModel.PktSharedData().iContext1.Deactivate(requestStatus);

	User::WaitForRequest(requestStatus);

	INFO_PRINTF2(_L("RPacketContext::Deactivate() completed %d\n"), requestStatus.Int());

	}

void CTestLtsyPktTestStepBase::GprsContextSetConfigTest()

	{

	// Set Context Config

	TRequestStatus reqStatusContextConfig = KErrNone;

	RPacketContext::TContextConfigGPRS contextConfig2;

	//contextConfig2.iServiceOption = RPacketContext::KLowSpeedData;

	contextConfig2.iPdpType  = RPacketContext::EPdpTypeIPv6;

	contextConfig2.iAccessPointName = KName;

	//contextConfig2.iPdpAddress = ;

	TPckg<RPacketContext::TContextConfigGPRS> contextConfigPckg2(contextConfig2);

	INFO_PRINTF1(_L("RPacketContext::SetConfig() invoked...\n"));

	iModel.PktSharedData().iContext1.SetConfig(reqStatusContextConfig, contextConfigPckg2);

	User::WaitForRequest(reqStatusContextConfig);

	INFO_PRINTF2(_L("RPacketContext::SetConfig() complete = %d\n"), reqStatusContextConfig.Int());

	}

void CTestLtsyPktTestStepBase::GprsContextGetConfigTest()

	{

	TRequestStatus reqStatusContextConfig = KErrNone;

	RPacketContext::TContextConfigGPRS contextConfig3;

	TPckg<RPacketContext::TContextConfigGPRS> contextConfigPckg3(contextConfig3);

	INFO_PRINTF1(_L("RPacketContext::GetConfig() invoked...\n"));

	iModel.PktSharedData().iContext1.GetConfig(reqStatusContextConfig, contextConfigPckg3);

	User::WaitForRequest(reqStatusContextConfig);

	INFO_PRINTF2(_L("RPacketContext::GetConfig() complete = %d\n"), reqStatusContextConfig.Int());

	contextConfig3 = contextConfigPckg3();

	}

void CTestLtsyPktTestStepBase::NotificationContextAddedCancel()

	{

	TName contextAddedContextId;

	TRequestStatus reqStatusContextAdded = KErrNone;

	INFO_PRINTF1(_L("Test Notify Context Added Cancel\n"));

	iModel.PktSharedData().iPacket.NotifyContextAdded(reqStatusContextAdded, contextAddedContextId);

	iModel.PktSharedData().iPacket.CancelAsyncRequest(EPacketNotifyContextAdded);

	User::WaitForRequest(reqStatusContextAdded);

	if (reqStatusContextAdded == KErrCancel)

		{

		INFO_PRINTF1(_L("Notify Context Added is KErrCancel\n"));

		}

	else 

		{

		INFO_PRINTF1(_L("Error - Notify Context Added status\n"));

		INFO_PRINTF2(_L("Error - Notify Context Added status = %d\n"), reqStatusContextAdded.Int());

		}

	}

void CTestLtsyPktTestStepBase::NotificationContextAdded()

	{

	TName contextAddedContextId;

	TRequestStatus reqStatusContextAdded = KErrNone;

	// Notify Context Added

	reqStatusContextAdded = KErrNone;

	contextAddedContextId = _L("ABCDEFGHIJKLMNOP");

	iModel.PktSharedData().iPacket.NotifyContextAdded(reqStatusContextAdded, contextAddedContextId);

	if (reqStatusContextAdded == KRequestPending)

		{

		INFO_PRINTF1(_L("Notify Context Added is KRequestPending\n"));

		}

	else

		{

		INFO_PRINTF1(_L("Notify Context Added request status\n"));

		INFO_PRINTF2(_L("Error - Notify Context Added status = %d\n"), reqStatusContextAdded.Int());

		}

	}

void CTestLtsyPktTestStepBase::OpenNewContext()

	{

	TInt returnStatus;

	// check if the slot is free to open

	if (NULL != iModel.PktSharedData().iContext1.SubSessionHandle())

		{

		ERR_PRINTF1(_L("Can't open the packet context before it's closed, aborting..."));

		}

	else

		{

	    returnStatus = iModel.PktSharedData().iContext1.OpenNewContext(iModel.PktSharedData().iPacket, iModel.PktSharedData().iContextName);

		if (KErrNone != returnStatus)

			{

			INFO_PRINTF2(_L("RPacketContext::OpenNewContext() ret = %d\n"), returnStatus);

			}

	    INFO_PRINTF2(_L("RPacketContext::OpenNewContext() ret = %d\n"), returnStatus);

	    INFO_PRINTF2(_L("Context Name = %S\n"), &iModel.PktSharedData().iContextName);

		}

	}

void CTestLtsyPktTestStepBase::OpenExistingContext()

	{

	// Open an existing context

	TInt returnStatus;

	returnStatus = iModel.PktSharedData().iContext3.OpenExistingContext(iModel.PktSharedData().iPacket, iModel.PktSharedData().iContextName);

	INFO_PRINTF2(_L("RPacketContext::OpenExistingContext() ret = %d\n"), returnStatus);

	INFO_PRINTF2(_L("Context3 Name = %S\n"), &iModel.PktSharedData().iContextName);

	}

void CTestLtsyPktTestStepBase::OpenContextUsingUnknownName()

{

	// Attempt to open a Context using an unknown name

	TInt returnStatus;

	TName bogusContextName;

	bogusContextName.Append(_L("Context"));

	bogusContextName.AppendNum(10);

	returnStatus = iModel.PktSharedData().iContext2.OpenExistingContext(iModel.PktSharedData().iPacket, bogusContextName);

	INFO_PRINTF2(_L("RPacketContext::OpenExistingContext() returnStatus = %d\n"), returnStatus);

}