// Copyright (c) 1997-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 <e32test.h>
#include "Te_LoopBackCCalls.h"

#include "../../hayes/TSYCONFG.H" // for KInternetAccessPoint

const TInt KOneSecond=1000000;		// One second Pause

//
// Test-side class
// With the assistance of the base class, this class must start the emulator
// and drive the ETel API.
//
CTestDriveAllCalls* CTestDriveAllCalls::NewL(const TScriptList aScriptListEntry)
	{
	CTestDriveAllCalls* phoneLine=new(ELeave) CTestDriveAllCalls(aScriptListEntry);
	CleanupStack::PushL(phoneLine);
	phoneLine->ConstructL();
	CleanupStack::Pop();
	return phoneLine;
	}

CTestDriveAllCalls::CTestDriveAllCalls(const TScriptList aScriptListEntry) : iScriptListEntry(aScriptListEntry)
	{
	
	}


TInt CTestDriveAllCalls::RunTestL()
	{
	iCurrentScript=iScriptListEntry;
	return StartEmulatorL();
	}

TInt CTestDriveAllCalls::DriveETelApiL()
//
// This function contains the real meat of the Client-side test code
//
	{
	TRequestStatus	reqStatus;
	INFO_PRINTF1(_L("Initialising the Phone..."));

	RMobilePhone::TMMTableSettings tableSettings;
	tableSettings.iLocId=KInternetAccessPoint;
	RMobilePhone::TMMTableSettingsPckg tableSettingsPckg(tableSettings);
	iPhone.InitialiseMM(reqStatus , tableSettingsPckg); 	

	User::WaitForRequest(reqStatus);

	TESTL(reqStatus == KErrNone);

	ERR_PRINTF1(_L("Voice Call tests"));
	TestVoiceCallL();
	User::After(5*KOneSecond);		// Give the user time to see the test results

	ERR_PRINTF1(_L("Cancel Requests test"));
	TestCancelRequestsL();
	User::After(5*KOneSecond);		// Give the user time to see the test results

	ERR_PRINTF1(_L("Data Call tests"));
	TestDataCallL();
	
	return KErrNone;
	}

void CTestDriveAllCalls::TestVoiceCallL()
/**
 * This function performs Voice call tests
 */
	{
	RProcess().SetPriority(EPriorityForeground);
	RThread().SetPriority(EPriorityNormal);
	_LIT(KVoiceLineName,"Voice");
	TRequestStatus status1;
	
	// Open a voice line and call
	RLine voiceLine;
	INFO_PRINTF1(_L("Opening Voice Line"));
	TESTL(voiceLine.Open(iPhone,KVoiceLineName)==KErrNone);

	RCall voiceCall;
	INFO_PRINTF1(_L("Opening New Voice Call"));
	TESTL(voiceCall.OpenNewCall(voiceLine)==KErrNone);

	// Get the call capabilities
	INFO_PRINTF1(_L("\nGet Call Capabilities...\n"));
	RCall::TCaps callCaps;
	TInt ret=voiceCall.GetCaps(callCaps);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetCaps() ***"));
	if (ret==KErrNotSupported)
		INFO_PRINTF1(_L("Get Call Capabilities is NOT Supported\n"));
	if (ret==KErrNone)
		{
		INFO_PRINTF1(_L("Get Call Capabilities is Successful\n"));
		
		if ((callCaps.iFlags&RCall::KCapsVoice) !=0)
			INFO_PRINTF1(_L("This call supports Voice calls\n"));
		}

	// Get the Call Status (The script has posted +CRING: VOICE, so the call is ringing!
	INFO_PRINTF1(_L("\nGet Call Status...\n"));
	RCall::TStatus callStatus;
	ret=voiceCall.GetStatus(callStatus);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetStatus() ***"));
	if (ret==KErrNotSupported)
		INFO_PRINTF1(_L("Get Call Status is NOT Supported\n"));
	if (ret==KErrNone)
		{
		TESTL(callStatus==RCall::EStatusRinging);
		INFO_PRINTF1(_L("This Voice call is currently ringing\n"));
		}

	// Answer an incoming call 
	voiceCall.AnswerIncomingCall(status1);		
	User::WaitForRequest(status1);
	TESTL(status1 == KErrNone);

	// Call Parameters
	INFO_PRINTF1(_L("\nGet Call Parameters...\n"));
	RCall::TCallParams callParams; 
	RCall::TCallParamsPckg callParamsPckg(callParams);
	ret=voiceCall.GetCallParams(callParamsPckg);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetCallParams() ***"));
	if (ret==KErrNotSupported)
		INFO_PRINTF1(_L("Get Call Parameters is NOT Supported\n"));
	if (ret==KErrNone)
		INFO_PRINTF1(_L("Get Call Parameters is successful\n"));
	
	INFO_PRINTF1(_L("The call is in progress...\n"));
	User::After(5*KOneSecond);

	// Bearer Service Information
	INFO_PRINTF1(_L("\nGet Bearer Service Info...\n"));
	RCall::TBearerService bearerServiceInfo;
	ret=voiceCall.GetBearerServiceInfo(bearerServiceInfo);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetBearerServiceInfo() ***"));
	if (ret==KErrNotSupported)
		INFO_PRINTF1(_L("Get BearerService Information is NOT Supported\n"));
	if (ret==KErrNone)
		INFO_PRINTF1(_L("Get BearerService Information is successful\n"));

	// Call Duration
	INFO_PRINTF1(_L("Get Call Duration...\n"));
	TTimeIntervalSeconds callDuration;
	ret=voiceCall.GetCallDuration(callDuration);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetCallDuration() ***"));
	if (ret==KErrNotSupported)
		{
		INFO_PRINTF1(_L("Get Current Call Duration is NOT Supported"));
		}
	if (ret==KErrNone)
		{
		INFO_PRINTF2(_L("Call duration = %d"), callDuration.Int());
		}

	// Call Information
	INFO_PRINTF1(_L("\nGet Current Call Info..."));
	RCall::TCallInfo callInfo;
	ret=voiceCall.GetInfo(callInfo);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetCallInfo() ***"));
	if (ret==KErrNotSupported)
		INFO_PRINTF1(_L("Get Current Call info is NOT Supported"));
	if (ret==KErrNone)
		{
		INFO_PRINTF1(_L("Displaying Information about the Current Call"));
		INFO_PRINTF2(_L("Call name: %S"), &callInfo.iCallName);
		INFO_PRINTF2(_L("Line name: %S"), &callInfo.iLineName);
		if (callInfo.iHookStatus==RCall::EHookStatusOff)
			{
			INFO_PRINTF1(_L("Current Hook Status: Off"));
			}
		if (callInfo.iStatus==RCall::EStatusConnected)
			{
			INFO_PRINTF1(_L("Current Call Status: Connected"));
			}
		}


	User::After(5*KOneSecond);		// Give the user time to see the test results

	// Call Ownership information
	INFO_PRINTF1(_L("Get Call Ownership..\n"));
	RCall::TOwnershipStatus callOwner;
	ret=voiceCall.GetOwnershipStatus(callOwner);
	CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("*** Failed RCall::GetOwnershipStatus() ***"));
	if (ret==KErrNotSupported)
		{
		INFO_PRINTF1(_L("Get Call OwnerShip is NOT Supported"));
		}
	else if (ret==KErrNone)
		{
		INFO_PRINTF1(_L("Get Call OwnerShip is Supported"));
		
		switch(callOwner)
			{
			case RCall::EOwnershipUnowned:
				INFO_PRINTF1(_L("The call is unowned"));
				break;
			case RCall::EOwnershipOwnedByAnotherClient:
				INFO_PRINTF1(_L("The call is owned by another Client"));
				break;
			case RCall::EOwnershipOwnedByThisClient:
				INFO_PRINTF1(_L("The call is owned by this client"));
				break;
			default:
				INFO_PRINTF1(_L("Error in Call Ownership details"));
				break;
			}	
		}
	else
		INFO_PRINTF2(_L("Get Call Ownership returned Error: %d"), ret);
		
	
	// Transfer Ownership Request (Note that no other client is interested in this call!)
	INFO_PRINTF1(_L("Voice Call 1 is trying to Transfer Ownership of the Call.."));
	ret=voiceCall.TransferOwnership();
	INFO_PRINTF2(_L("Transfer Ownership Request returned %d"), ret);
	if (ret==KErrEtelNoClientInterestedInThisCall)
		INFO_PRINTF1(_L("There is no Client interested in this call."));


	// Hang up Cancel Request
	TRequestStatus cancelStatus;
	INFO_PRINTF1(_L("Hang Up Cancel Request")); 
	voiceCall.HangUp(cancelStatus);
	User::After(3*KOneSecond);		// Want the TSY to receive the Hang up command.
	voiceCall.HangUpCancel();
	User::WaitForRequest(cancelStatus);
	TESTL(cancelStatus==KErrNone);
	if (cancelStatus==KErrNone)
		{
		INFO_PRINTF1(_L("Hang up cancel Request Unsuccessful."));
		INFO_PRINTF1(_L("The Voice call has been dropped."));
		INFO_PRINTF1(_L("This is expected behaviour!."));
		}
	else 
		{
		INFO_PRINTF1(_L("Hang up cancel Request Successful."));
		INFO_PRINTF1(_L("This is unexpected!. Going to assume that the call has been dropped"));
		}
	
	// Close the voice line and calls
	voiceLine.Close();
	voiceCall.Close();
 	RProcess().SetPriority(EPriorityHigh);
 	RThread().SetPriority(EPriorityMuchMore);	
	}

void CTestDriveAllCalls::TestCancelRequestsL()
/**
 * This function tests Cancel Requests, Notifications in particular.
 */
	{
	_LIT(KVoiceLineName,"Voice");
	
	// Open a voice line and call
	RLine voiceLine;
	INFO_PRINTF1(_L("Opening Voice Line"));
	TESTL(voiceLine.Open(iPhone,KVoiceLineName)==KErrNone);

	RCall voiceCall;
	INFO_PRINTF1(_L("Opening a new Voice Call"));
	TESTL(voiceCall.OpenNewCall(voiceLine)==KErrNone);

	RCall voiceCall2;
	INFO_PRINTF1(_L("Opening a 2nd Voice Call"));
	TESTL(voiceCall2.OpenNewCall(voiceLine)==KErrNone);

	// Answer Incoming call Cancel Request
	TRequestStatus cancelStatus;
	INFO_PRINTF1(_L("Answer Incoming Call Cancel Request")); 
	voiceCall.AnswerIncomingCall(cancelStatus);
	voiceCall.AnswerIncomingCallCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("Answer Incoming Cancel status = %d"), cancelStatus.Int());

	// Notify Hook Change Cancel Request
	INFO_PRINTF1(_L("Notify Hook Change Cancel Request")); 
	RCall::THookStatus hookStatus;
	voiceCall.NotifyHookChange(cancelStatus, hookStatus);
	voiceCall.NotifyHookChangeCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("Notify Hook Change Cancel status = %d"), cancelStatus.Int());

	// Notify Caps Change Cancel Request
	INFO_PRINTF1(_L("Notify Caps change Cancel Request")); 
	RLine::TCaps lineCaps;
	voiceLine.NotifyCapsChange(cancelStatus, lineCaps);
	voiceLine.NotifyCapsChangeCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("Notify caps Change Cancel status = %d"), cancelStatus.Int());

	// Notify Call Status Change Cancel Request
	INFO_PRINTF1(_L("Notify CallStatusChange Cancel Request...")); 
	RCall::TStatus callStatus1;
	voiceCall.NotifyStatusChange(cancelStatus, callStatus1);
	voiceCall.NotifyStatusChangeCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("Notify CallStatusChange Cancel: %d"), cancelStatus.Int());

	// Notify CallDuration Change Cancel Request
	INFO_PRINTF1(_L("NotifyCallDurationChange Cancel Request...")); 
	TTimeIntervalSeconds callDuration;
	voiceCall.NotifyCallDurationChange(cancelStatus, callDuration);
	voiceCall.NotifyCallDurationChangeCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("Notify CallDurationChange Cancel: %d"), cancelStatus.Int());

	// Acquire Ownership Cancel Request 
	INFO_PRINTF1(_L("AcquireOwnership Cancel Request..."));
	voiceCall2.AcquireOwnership(cancelStatus);
	voiceCall2.AcquireOwnershipCancel();
	User::WaitForRequest(cancelStatus);
	if (cancelStatus==KErrEtelCallNotActive)
		{
		INFO_PRINTF1(_L("Voice Call 2 is not currently active"));
		}
	else
		{
		INFO_PRINTF2(_L("AcquireOwnership Cancel status: %d"), cancelStatus.Int());
		}

	// Close the voice line and call
	voiceLine.Close();
	voiceCall.Close();
	voiceCall2.Close();
	}

void CTestDriveAllCalls::TestDataCallL()
/**
 * This function performs Data calls tests.
 */
	{
	// The script has posted a +CRING: REL ASYNC, so a data call is expected
	INFO_PRINTF1(_L("\nAnswering an incoming data call.\n"));

	_LIT(KDataLineName,"Data");
	
	// Open a Data line
	RLine dataLine;
	INFO_PRINTF1(_L("Opening Data Line"));
	TESTL(dataLine.Open(iPhone,KDataLineName)==KErrNone);

	// Post a Notification on an Incoming call
	TRequestStatus notifyStatus;
	TName callName;
	dataLine.NotifyIncomingCall(notifyStatus, callName);
	User::WaitForRequest(notifyStatus);
	TESTL(notifyStatus==KErrNone);	
	INFO_PRINTF1(_L("An incoming data call has been detected."));

	// Open and answer a Data call
	RCall dataCall;
	TRequestStatus status1;
	TESTL(dataCall.OpenExistingCall(dataLine, callName)==KErrNone);
	
	dataCall.AnswerIncomingCall(status1);		
	User::WaitForRequest(status1);
	TESTL(status1 == KErrNone);

	// Get the call's status
	RCall::TStatus callStatus;
	TESTL(dataCall.GetStatus(callStatus)==KErrNone);
	if (callStatus==RCall::EStatusConnected)
		{
		INFO_PRINTF1(_L("Call Status: CONNECTED"));
		}

	// LoanDataPort (Cancel) request
	INFO_PRINTF1(_L("Loan Data Port Cancel request."));
	RCall::TCommPort commPort;
	TRequestStatus cancelStatus;
	dataCall.LoanDataPort(cancelStatus,commPort);
	User::After(3*KOneSecond);		// Want the request to get through to the TSY
	dataCall.LoanDataPortCancel();
	User::WaitForRequest(cancelStatus);
	INFO_PRINTF2(_L("LoanDataPort Cancel: %d"), cancelStatus.Int());
	
	if (cancelStatus==KErrNone)
		{
		INFO_PRINTF1(_L("LoanDataPort Cancel request NOT successful."));
		}
	else
		{
		INFO_PRINTF1(_L("LoanDataPort cancel request was successful."));
		INFO_PRINTF1(_L("This is unexpected, the rest of the test will not be executed!!"));
		INFO_PRINTF1(_L("Closing the data line and call."));
		dataLine.Close();	
		dataCall.Close();		
		return;
		}

	// Connect to the Comms Server and Open a serial port
	INFO_PRINTF1(_L("Connecting to the Comms server and opening a serial port."));
	RCommServ commServer;
	TESTL(commServer.Connect()==KErrNone);

	RComm port;
	TESTL(port.Open(commServer,commPort.iPort,ECommShared)==KErrNone);

	// Write some data to the serial port
	TRequestStatus writeStatus;
	_LIT8(KTestData,"Telephony Test Code\r\n");
	port.Write(writeStatus,KTestData);
	User::WaitForRequest(writeStatus);
	TESTL(writeStatus==KErrNone);
	INFO_PRINTF1(_L("Data has been successfully written to the serial port"));

	// Close the serial port & the comms Server. Recover the data port & hang up the call.
	port.Close();
	commServer.Close();
	TESTL(dataCall.RecoverDataPort()==KErrNone);

	INFO_PRINTF1(_L("Hanging up the Data call."));
	TESTL(dataCall.HangUp()==KErrNone);

	// Close the Data line and call
	dataLine.Close();
	dataCall.Close();		
	}


//
// Emulator-side class
// With the assistance of the base class, this class must run the designated script
//
CTestAllCalls* CTestAllCalls::NewL(const TScript* aScript)
	{
	CTestAllCalls* allCalls=new(ELeave) CTestAllCalls(aScript);
	CleanupStack::PushL(allCalls);
	allCalls->ConstructL();
	CleanupStack::Pop();
	return allCalls;
	}

CTestAllCalls::CTestAllCalls(const TScript* aScript) : iScript(aScript)
	{}

void CTestAllCalls::ConstructL()
	{
	CATScriptEng::ConstructL();
	}

TInt CTestAllCalls::Start()
	{
	StartScript(iScript);
	return KErrNone;
	}

void CTestAllCalls::SpecificAlgorithmL(TInt /* aParam */)
	{
    }

void CTestAllCalls::Complete(TInt aError)
	{
	iReturnValue=aError;
	CActiveScheduler::Stop();
	}