// Copyright (c) 2002-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:

//

/**

 @file

*/

#include "Te_SimData.h"

#include <sacls.h>

const TInt KTenPartOfSec = 100000 ;

const TInt KOneSecond=1000000;	// Used in a time out function, 1 second (in microSeconds)

const TInt KTenSeconds=10000000;	// Used in a time out function, 10 seconds (in microSeconds)

_LIT(KGoodNumber,"1789");

static TInt NTRasThreadFunction(TAny* /*aThreadData*/)

/**

* Does 'durty' work to  start NT RAS session

* @note It sets

*	iRate = EBps38400;

*	iDataBits = EData8;

*	iStopBits = EStop1 ;

*	iParity = EParityNone;

* be sure that your NT comport has the same settings.

*/

	{

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName,"LOOPBACK::1");

	_LIT8(KServerText,"SERVER");

	CTrapCleanup* cleanup;

	if ((cleanup=CTrapCleanup::New())==NULL)

		return KErrGeneral;

	RCommServ commServ;

	TInt r=commServ.Connect();

	r=commServ.LoadCommModule(KCsyName);

	if( KErrNone == r)

		{

		RComm comm;

		r=comm.Open(commServ,KPortName,ECommShared);

		if( KErrNone == r)

			{

			TBuf8<6> readBuf;

			TRequestStatus stat0;

			comm.Read(stat0,readBuf);

			User::WaitForRequest(stat0) ;

			comm.Write(stat0,KServerText);

			User::WaitForRequest(stat0) ;

			}

		comm.Close() ;

		}

	commServ.Close() ;

	delete cleanup;

	return r;

	}

LOCAL_C TInt StartNTRasSimulation()

/**

* Starts virual, because of lookback serial driver,

* NT RAS session

*/

	{

	const TInt KStackSize=0x8000;

	const TInt KHeapSize=0x8000;

	const TInt KMaxHeapSize=0x80000;

	TInt res = KErrNone ;

	_LIT(KNtRasName,"NTRasEmulation");

	RThread t;

	res=t.Create(KNtRasName,NTRasThreadFunction,

					KStackSize,KHeapSize,KMaxHeapSize,NULL);

	t.Resume();

	t.Close();

	return res;

	}

void CTestSimDataStep::WaitWithTimeout(TRequestStatus& aStatus, TInt aNumberOfMicroSeconds)

/**

 * Timeout function

 */

	{

	TRequestStatus timerStatus;

	RTimer timer ;

	timer.CreateLocal() ;

	timer.After(timerStatus,aNumberOfMicroSeconds);

	User::WaitForRequest(aStatus, timerStatus);

	if (timerStatus == KRequestPending)

		{

		timer.Cancel();

		User::WaitForRequest(timerStatus);

		}

	else

		{

		INFO_PRINTF1(_L("Time is over!!!")) ;

		}

	timer.Close() ;

	}

//

// CTestSimDataStep Implementation

//

void CTestSimDataStep::GetGoodNumber(TDes& aNum)

/**Returns string with number for outgoing call.

 * For.ex Good number is 179 Vodaphone test line - recorded message.

 * Function tries to read value of switch /modem, otherwise it use defualt value.

 * @return phone number string

 * @note have to be updated to read information from cmd line or config. file

*/

	{

	aNum.Copy(KGoodNumber) ;

	}

void CTestSimDataStep::TestLineCapabilitiesL()

/**

 * @test GT83-TDATA-002.01 Test retrieval of a data line's capabilities. Display the capabilities to screen

*/

	{

	INFO_PRINTF1(_L("Test Line Capabilities"));

	// Line Capabilities

	RLine::TCaps lineCaps;

	TInt ret=iLine.GetCaps(lineCaps);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-002.01")) ;

	if (ret!=KErrNone)

		{

		INFO_PRINTF1(_L("Get Line Capabilities is NOT supported"));

		}

	else

		{

		if ((lineCaps.iFlags&RLine::KCapsData) !=0)

			{

			INFO_PRINTF1(_L("This line supports Data connections"));

			}

		if ((lineCaps.iFlags&RLine::KCapsFax) !=0)

			{

			INFO_PRINTF1(_L("This line supports Fax connections"));

			}

		if ((lineCaps.iFlags&RLine::KCapsVoice) !=0)

			{

			INFO_PRINTF1(_L("This line supports Voice connections"));

			}

		if ((lineCaps.iFlags&RLine::KCapsEventIncomingCall) !=0)

			{

			INFO_PRINTF1(_L("This line supports Incoming Call Notification requests"));

			}

		}

	}

TInt CTestSimDataStep::CallMeDear()

/**

* Asks for incomming call

* @return KErrNone if could make it

*/

	{

	iState++;

	TInt ret = RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyIncomingDataCall, iState);

	INFO_PRINTF2(_L("Set Incoming Call Publish & Subscribe property result: %d"),ret) ;

	return ret;

	}

TInt CTestSimDataStep::HangMeUpDear()

/**

* Asks for remote hangup

* @return KErrNone if could make it

*/

	{

	iState++;

	TInt ret = RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyRemoteHangup, iState);

	INFO_PRINTF2(_L("Set Remote Hangup Publish & Subscribe property result: %d"),ret) ;

	return ret;

	}

void CTestSimDataStep::Print_RCall_TStatus(RCall::TStatus& aArg)

/** Display value of enum RCall::TStatus to screen.

 * @param value to print

*/

	{

	switch(aArg)

		{

		case RCall::EStatusUnknown:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusUnknown")) ;

		break ;

		case RCall::EStatusIdle:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusIdle")) ;

		break ;

		case RCall::EStatusDialling:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusDialling")) ;

		break ;

		case RCall::EStatusRinging:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusRinging")) ;

		break ;

		case RCall::EStatusAnswering:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusAnswering")) ;

		break ;

		case RCall::EStatusConnecting:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusConnecting")) ;

		break ;

		case RCall::EStatusConnected:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusConnected")) ;

		break ;

		case RCall::EStatusHangingUp:

			INFO_PRINTF1(_L("Value of enum is RCall::EStatusHangingUp")) ;

		break ;

		}

	}

void CTestSimDataStep::Print_TCapsEnum(RCall::TCaps& aArg)

/** Display value of enum RCall::TCapsEnum to screen.

 * @param value to print

*/

	{

	if(aArg.iFlags & RCall::KCapsData)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsData")) ;

		}

	if(aArg.iFlags & RCall::KCapsFax)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsFax")) ;

		}

	if(aArg.iFlags & RCall::KCapsVoice)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsVoice")) ;

		}

	if(aArg.iFlags & RCall::KCapsDial)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsDial")) ;

		}

	if(aArg.iFlags & RCall::KCapsConnect)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsConnect")) ;

		}

	if(aArg.iFlags & RCall::KCapsHangUp)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsHangUp")) ;

		}

	if(aArg.iFlags & RCall::KCapsAnswer)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsAnswer")) ;

		}

	if(aArg.iFlags & RCall::KCapsLoanDataPort)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsLoanDataPort")) ;

		}

	if(aArg.iFlags & RCall::KCapsRecoverDataPort)

		{

			INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsRecoverDataPort")) ;

		}

	}

//------------------------------------------------------------------

CTestLineStatusIncommingCall::CTestLineStatusIncommingCall()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("TestLineStatusIncommingCall"));

	}

//------------------------------------------------------------------

TVerdict CTestLineStatusIncommingCall::doTestStepL()

/**	 Tests line status function

 * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

 * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic)

 * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle"""

 * @test GT83-TDATA-004.04 "Test retrieval of a data line's current status when the line's status is ""Ringing"""

 * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected"""

 * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up"""

 * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call

 * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic)

 * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic)

 * @test GT83-TDATA-031.01 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Idle"""

 * @test GT83-TDATA-031.04 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Answering"""

 * @test GT83-TDATA-031.07 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Waiting CCBS Recall"""

*/

	{

	INFO_PRINTF1(_L("Test Line Status"));

	//to make sure that line and call will be closed in leave case

	CleanupClosePushL(iLine);

	CleanupClosePushL(iDataCall);

	RMobileCall::TMobileDataCallParamsV1 callDataParams;

	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

	RCall::TStatus lineStatus;

	TBuf<16> GoodNumber ;

	GetGoodNumber(GoodNumber) ;

	// Open a Data line and Call

	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

	INFO_PRINTF1(_L("Opening Data Line"));

	CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

	TInt ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.00")) ;

	CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

	RMobileCall::TMobileCallStatus mobileLineStatus;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.00")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ;

	INFO_PRINTF1(_L("Please ring the phone"));

	TName callName;

	/* @test GT83-AT-024	Test setting notification of an incoming call on a data line */

	iLine.NotifyIncomingCall(iStatus, callName);	// wait for a call

	CallMeDear() ;

	WaitWithTimeout(iStatus,20*KOneSecond);				// but timeout after 60 seconds

	CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ;

	/* @test GT83-AT-36	Test retrieval of the current call status when it is ringing*/

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ;

	CHECK_POINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-0")) ;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-008.001")) ;

	INFO_PRINTF1(_L("Phone is ringing..."));

	//Test for incomming data call

	TestLineCapabilitiesL();

	/* @test GT83-AT-028	Test opening a new call by specifying the name of a line

	*/

	ret = iDataCall.OpenExistingCall(iLine, callName);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-014.05")) ;

	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

	callDataParams.iSpeed = RMobileCall::ESpeed9600;

	callDataParams.iProtocol = RMobileCall::EProtocolV32;

	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

	// Answer an incoming call initiated by t_echo.exe and obtain the call's current status

	//GT83-AT-032	Test answering a call on a data line (Generic)	RCall::AnswerIncomingCall

	iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg);

	WaitWithTimeout(iStatus,30*KOneSecond);		// but timeout after 2 seconds

	CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ;

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.04")) ;

	CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.04")) ;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.04")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.04")) ;

	TestLineCapabilitiesL();

	/* @test GT83-AT-36	Test retrieval of the current call status when it is connected*/

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ;

	CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.07")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.07")) ;

	INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));

	User::After(10*KOneSecond);

	INFO_PRINTF1(_L("Hanging Up"));

	iDataCall.HangUp(iStatus);

	/* @test GT83-AT-36	Test retrieval of the current call status when it is hang up*/

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.08")) ;

	CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-0")) ;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.09")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-004.09")) ;

	User::WaitForRequest(iStatus);

	//CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ;  //???  line 825

	//This test has some trobles with Erikson phones

	//R520m could return KErrGeneral

	//SH888 could return KErrTimedOut

	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ;

	CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

	ret = iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ;

	CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

	// Close the line and call

	CleanupStack::PopAndDestroy(&iDataCall) ;

	CleanupStack::PopAndDestroy(&iLine) ;

	return TestStepResult();

	}

//------------------------------------------------------------------

CTestLineStatusOutgoingCall::CTestLineStatusOutgoingCall()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("TestLineStatusOutgoingCall"));

	}

//------------------------------------------------------------------

TVerdict CTestLineStatusOutgoingCall::doTestStepL()

/**	 Tests line status function

 * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

 * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic)

 * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle"""

 * @test GT83-TDATA-004.03 "Test retrieval of a data line's current status when the line's status is ""Dialling"""

 * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected"""

 * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up"""

 * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call

 * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic)

 * @test GT83-TDATA-031.01 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Idle"""

*/

	{

	INFO_PRINTF1(_L("Test Line Status"));

	TInt ret = RProperty::Set(KUidSystemCategory, KUidPhonePwrValue, ESAPhoneOff);

	if(ret!=KErrNone)

		{

		INFO_PRINTF2(_L("Failed to set property KUidSystemCategory/KUidPhonePwr to ESAPhoneOff. The error was %d. Continuing..."),ret);

		}

	User::After(5 * 1000000);	// sleep 5 secs; make sure phone is off

	//to make sure that line and call will be closed in leave case

	CleanupClosePushL(iLine);

	CleanupClosePushL(iDataCall);

	StartNTRasSimulation();

	RMobileCall::TMobileDataCallParamsV1 callDataParams;

	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

	TName callName;

	RCall::TStatus lineStatus;

	TBuf<16> GoodNumber ;

	GetGoodNumber(GoodNumber) ;

	// Open a Data line and Call

	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

	INFO_PRINTF1(_L("Opening Data Line"));

	CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

	iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.00")) ;

	CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

	RMobileCall::TMobileCallStatus mobileLineStatus;

	iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.00")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ;

	/* @test GT83-AT-028	Test opening a new call by specifying the name of a line

	*/

	iDataCall.OpenNewCall(iLine, callName);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-014.05")) ;

	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

	callDataParams.iSpeed = RMobileCall::ESpeed9600;

	callDataParams.iProtocol = RMobileCall::EProtocolV32;

	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

	INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);

	iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber);

	iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.03")) ;

	//CHECK_POINT(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-004.03")) ;

	WaitWithTimeout(iStatus,20*KOneSecond);				// but timeout after 60 seconds

	CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ;

	//Test for outgoing data call

	TestLineCapabilitiesL();

	/* @test GT83-AT-36	Test retrieval of the current call status when it is connected*/

	iLine.GetStatus(lineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ;

	CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ;

	iLine.GetMobileLineStatus(mobileLineStatus);

	CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ;

	CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-0")) ;

	INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));

	User::After(10*KOneSecond);

	INFO_PRINTF1(_L("Call connected - listen for 20 seconds..."));