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

// This file contains the implementation of the Simulator TSY Data Call functionality.  

// The Call classes process the Call-based requests made by ETel clients 

// and passed down to the TSY by the ETel Server.

// 

//

/**

 @file

*/

#include <testconfigfileparser.h>

#include "CSimDataCall.h"

#include "CSimPhone.h"

#include "Simlog.h"

CSimDataCall* CSimDataCall::NewL(CSimLine* aLine,const TDesC& aName, CSimPhone* aPhone)

/**

 * Standard two phase constructor.

 *

 * @param aLine pointer to the Line object.

 * @param aName name of the call to be constructed

 * @return CSimDataCall  pointer to the data call object created

 * @leave Leaves if no memory or object is not created for any reason

 */

	{

	CSimDataCall* dataCall=new(ELeave) CSimDataCall(aLine,aName,aPhone);

	TCleanupItem newCallDataClose(CloseCall,dataCall);

	CleanupStack::PushL(newCallDataClose);

	dataCall->ConstructL();

	CleanupStack::Pop();

	return dataCall;

	}

CSimDataCall::CSimDataCall(CSimLine* aLine,const TName& aName, CSimPhone* aPhone)

	: CSimCall(aLine,aName,aPhone), iCommPortLoaned(EFalse)

/**

 * Trivial constructor. Calls CSimCall to initialise its members

 */

	{

	iCaps=Caps();

	}

void CSimDataCall::ConstructL()

/**

 * Second phase of 2-Phase Constructor

 * Retrieves all the pausing duration tags from the config file

 *

 * @param aName name of the data call to be constructed

 */

	{

	LOGDATA1("Starting to parse Data Call config parameters...");

	iDiallingPause=iLine->CfgFile()->ItemValue(KDiallingPauseDuration,KDefaultDiallingPauseDuration);

	iConnectingPause=iLine->CfgFile()->ItemValue(KConnectingPauseDuration,KDefaultConnectingPauseDuration);

	iDisconnectingPause=iLine->CfgFile()->ItemValue(KDisconnectingPauseDuration,KDefaultDisconnectingPauseDuration);

	iAnswerIncomingPause=iLine->CfgFile()->ItemValue(KAnswerIncomingPauseDuration,KDefaultAnswerIncomingPauseDuration);

	iRemoteHangupPause=iLine->CfgFile()->ItemValue(KRemoteHangupPauseDuration,KDefaultRemoteHangupPauseDuration);

// Read in the CommPort setup

	const CTestConfigItem* item=iLine->CfgFile()->Item(KDataCallCaps);

	if(item)

		{

		TPtrC8 speedCaps, protocolCaps, serviceCaps, qosCaps, codingCaps, asymmetryCaps;

		TPtrC8 rlpVersionCaps, v42bisCaps;

		TBool   hscsdSupport, userInitUpgrade;

		TInt mClass, MaxRxTimeslots, MaxTxTimeslots, totalRxTxTimeslots;

		TUint8 digit = 0;

		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,speedCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("speedCaps",ret,0,&KDataCallCaps);

			}

		else

			if(AsciiToNum(speedCaps, digit)==KErrNone)

				iMobileCallCaps.iSpeedCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,protocolCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("protocolCaps",ret,1,&KDataCallCaps);

			}

		else

			if(AsciiToNum(protocolCaps, digit)==KErrNone)

				iMobileCallCaps.iProtocolCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,serviceCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("serviceCaps",ret,2,&KDataCallCaps);

			}

		else

			if(AsciiToNum(serviceCaps, digit)==KErrNone)

				iMobileCallCaps.iServiceCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,qosCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("qosCaps",ret,3,&KDataCallCaps);

			}

		else

			if(AsciiToNum(qosCaps, digit)==KErrNone)

				iMobileCallCaps.iQoSCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,hscsdSupport);

		if(ret!=KErrNone)

			{

			LOGPARSERR("hscsdSupport",ret,4,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iHscsdSupport = hscsdSupport;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,mClass);

		if(ret!=KErrNone)

			{

			LOGPARSERR("mClass",ret,5,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iMClass = mClass;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,MaxRxTimeslots);

		if(ret!=KErrNone)

			{

			LOGPARSERR("MaxRxTimeslots",ret,6,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iMaxRxTimeSlots = MaxRxTimeslots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,MaxTxTimeslots);

		if(ret!=KErrNone)

			{

			LOGPARSERR("MaxTxTimeslots",ret,7,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iMaxTxTimeSlots = MaxTxTimeslots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,totalRxTxTimeslots);

		if(ret!=KErrNone)

			{

			LOGPARSERR("totalRxTxTimeslots",ret,8,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iTotalRxTxTimeSlots = totalRxTxTimeslots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,codingCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("codingCaps",ret,9,&KDataCallCaps);

			}

		else

			if(AsciiToNum(codingCaps, digit)==KErrNone)

				iMobileCallCaps.iCodingCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,asymmetryCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("asymmetryCaps",ret,10,&KDataCallCaps);

			}

		else

			if(AsciiToNum(asymmetryCaps, digit)==KErrNone)

				iMobileCallCaps.iAsymmetryCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,userInitUpgrade);

		if(ret!=KErrNone)

			{

			LOGPARSERR("userInitUpgrade",ret,11,&KDataCallCaps);

			}

		else

			iMobileCallCaps.iUserInitUpgrade = userInitUpgrade;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,rlpVersionCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("rlpVersionCaps",ret,10,&KDataCallCaps);

			}

		else

			if(AsciiToNum(rlpVersionCaps, digit)==KErrNone)

				iMobileCallCaps.iRLPVersionCaps = digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,v42bisCaps);

		if(ret!=KErrNone)

			{

			LOGPARSERR("v42bisCaps",ret,10,&KDataCallCaps);

			}

		else

			if(AsciiToNum(v42bisCaps, digit)==KErrNone)

				iMobileCallCaps.iV42bisCaps  = digit;

		}

		else //Default Values for Caps

			{

			iMobileCallCaps.iSpeedCaps=RMobileCall::KCapsSpeedAutobauding;

			iMobileCallCaps.iProtocolCaps=RMobileCall::KCapsProtocolV32;

			iMobileCallCaps.iServiceCaps=(RMobileCall::KCapsDataCircuitAsynchronous | RMobileCall::KCapsPacketAccessSyncUDI);

			iMobileCallCaps.iQoSCaps=RMobileCall::KCapsTransparentPreferred;

			iMobileCallCaps.iHscsdSupport=(TBool)(ETrue);

			iMobileCallCaps.iMClass=1;

			iMobileCallCaps.iMaxRxTimeSlots=5;

			iMobileCallCaps.iMaxTxTimeSlots=5;

			iMobileCallCaps.iTotalRxTxTimeSlots=10;

			iMobileCallCaps.iCodingCaps=(RMobileCall::KCapsAiurCoding48 | RMobileCall::KCapsAiurCoding96);

			iMobileCallCaps.iAsymmetryCaps=(RMobileCall::EAsymmetryUplink);

			iMobileCallCaps.iUserInitUpgrade=(TBool)(ETrue);

			iMobileCallCaps.iRLPVersionCaps = 1;

			iMobileCallCaps.iV42bisCaps = 1;

		}

	TInt count = iLine->CfgFile()->ItemCount(KDataRLPparams);

	TMobileCallRLPItem iMobileCallRLPItem;

	iMobileCallRLPList = new(ELeave) CArrayFixFlat<TMobileCallRLPItem>(5);

	if(count!=0)

		{

		for(TInt i=0;i<count;i++)

			{

			item = iLine->CfgFile()->Item(KDataRLPparams,i);

			if(!item)

				break;

			TInt iRlpVersion,iIWSMax,iIWSMin,iMWSMax,iMWSMin;

			TInt iT1Max,iT1Min,iN2Max,iN2Min,iT4Max,iT4Min;

			TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iRlpVersion);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iRlpVersion",ret,0,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iRlpVersion = iRlpVersion;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iIWSMax);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iIWSMax",ret,0,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iIWSMax = iIWSMax;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iIWSMin);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iIWSMin",ret,1,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iIWSMin = iIWSMin;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iMWSMax);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iMWSMax",ret,2,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iMWSMax = iMWSMax;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iMWSMin);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iMWSMin",ret,3,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iMWSMin = iMWSMin;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iT1Max);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iT1Max",ret,4,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iT1Max = iT1Max;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,iT1Min);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iT1Min",ret,5,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iT1Min = iT1Min;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,iN2Max);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iN2Max",ret,6,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iN2Max = iN2Max;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,iN2Min);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iN2Min",ret,7,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iN2Min = iN2Min;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,iT4Max);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iT4Max",ret,8,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iT4Max = iT4Max;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,iT4Min);

			if(ret!=KErrNone)

				{

				LOGPARSERR("iT4Min",ret,9,&KDataRLPparams);

				}

			else

				iMobileCallRLPItem.iMobileCallRLP.iT4Min = iT4Min;

			iMobileCallRLPList->AppendL(iMobileCallRLPItem);		

			}

		}

	else 

		{

		iMobileCallRLPItem.iRlpVersion=1;

		iMobileCallRLPItem.iMobileCallRLP.iIWSMax=10;

		iMobileCallRLPItem.iMobileCallRLP.iIWSMin=5;

		iMobileCallRLPItem.iMobileCallRLP.iMWSMax=8;

		iMobileCallRLPItem.iMobileCallRLP.iMWSMin=4;

		iMobileCallRLPItem.iMobileCallRLP.iT1Max=4;

		iMobileCallRLPItem.iMobileCallRLP.iT1Min=2;

		iMobileCallRLPItem.iMobileCallRLP.iN2Max=12;

		iMobileCallRLPItem.iMobileCallRLP.iN2Min=1;

		iMobileCallRLPItem.iMobileCallRLP.iT4Max=10;

		iMobileCallRLPItem.iMobileCallRLP.iT4Min=2;

		iMobileCallRLPList->AppendL(iMobileCallRLPItem);

		}

	item=iLine->CfgFile()->Item(KDynamicHSCSDInfo);

	if(item)

		{		

		TPtrC8 iAiur,iCodings;

		TInt iRxTimeSlots,iTxTimeSlots;

		TUint8 digit=0;

		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iAiur);

		if(ret!=KErrNone)

			{

			LOGPARSERR("iAiur",ret,0,&KDynamicHSCSDInfo);

			}

		else

			if(AsciiToNum(iAiur, digit)==KErrNone)

				iHscsdInfo.iAiur = (RMobileCall::TMobileCallAiur) digit;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iRxTimeSlots);

		if(ret!=KErrNone)

			{

			LOGPARSERR("iRxTimeSlots",ret,1,&KDynamicHSCSDInfo);

			}

		else

			iHscsdInfo.iRxTimeSlots = iRxTimeSlots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iTxTimeSlots);

		if(ret!=KErrNone)

			{

			LOGPARSERR("iTxTimeSlots",ret,2,&KDynamicHSCSDInfo);

			}

		else

			iHscsdInfo.iTxTimeSlots = iTxTimeSlots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iCodings);

		if(ret!=KErrNone)

			{

			LOGPARSERR("iCodings",ret,3,&KDynamicHSCSDInfo);

			}

		else

			if(AsciiToNum(iCodings, digit)==KErrNone)

				iHscsdInfo.iCodings = (RMobileCall::TMobileCallTchCoding) digit;

	}

	else 

		{

		iHscsdInfo.iAiur=RMobileCall::EAiurBps9600;

		iHscsdInfo.iRxTimeSlots=5;

		iHscsdInfo.iTxTimeSlots=10;

		iHscsdInfo.iCodings=RMobileCall::ETchCoding48;

	}

	item=iLine->CfgFile()->Item(KCommSetup);

	if(item)

		{

		TPtrC8 portName,csyName;

		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,csyName);	// The 3rd parameter (0) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("csyName",err,0,&KCommSetup);

			iCsyName.Copy(KDefaultCsyName);

			}

		else

			iCsyName.Copy(csyName);

		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,portName);		// The 3rd parameter (1) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("portName",err,1,&KCommSetup);

			iPortName.Copy(KDefaultPortName);

			}

		else

			iPortName.Copy(portName);

		TInt dataRate,handshake;

		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dataRate);		// The 3rd parameter (2) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("dataRate",err,2,&KCommSetup);

			iConfig.iRate=KDefaultCommPortRate;

			}

		else

			iConfig.iRate=(TBps)dataRate;

		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,handshake);		// The 3rd parameter (3) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("handshake",err,3,&KCommSetup);

			iConfig.iHandshake=KDefaultHandshake;

			}

		else

			iConfig.iHandshake=(TUint)handshake;

		}

	else

		{

		iCsyName.Copy(KDefaultCsyName);

		iPortName.Copy(KDefaultPortName);

		iConfig.iRate=KDefaultCommPortRate;

		iConfig.iHandshake=KDefaultHandshake;

		}

// Read in the Bearer Service information

	item=iLine->CfgFile()->Item(KBearerService);

	if(item)

		{

		TInt bearerCaps,bearerSpeed;

		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,bearerCaps);	// The 3rd parameter (0) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("bearerCaps",err,0,&KBearerService);

			iBearerService.iBearerCaps=KDefaultBearerCaps;

			}

		else

			iBearerService.iBearerCaps=bearerCaps;

		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,bearerSpeed);		// The 3rd parameter (1) represents the index of the variable on the config file line

		if (err!=KErrNone)

			{

			LOGPARSERR("bearerSpeed",err,1,&KBearerService);

			iBearerService.iBearerSpeed=KDefaultBearerSpeed;

			}

		else

			iBearerService.iBearerSpeed=(RCall::TCallBearerSpeed)bearerSpeed;

		}

	else

		{

		iBearerService.iBearerCaps=KDefaultBearerCaps;

		iBearerService.iBearerSpeed=KDefaultBearerSpeed;

		}

	iTimer=CSimTimer::NewL(iLine->iPhone);

	iNtRas=CSimNtRas::NewL(iLine->iPhone);

	CSimCall::ConstructL();

	//If present read in remote party info tag

 	TPtrC8 callingname, remotenumber;

 	TInt delay=0;

 	item=iLine->CfgFile()->Item(KNotifyRemotePartyInfo);

 	TInt ret;

 	if (item)

 		{

 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay);

 		if(ret!=KErrNone)

 			{

 			LOGPARSERR("delay",ret,0,&KNotifyRemotePartyInfo);

 			}

 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,callingname);

 		if(ret!=KErrNone)

 			{

 			LOGPARSERR("callingname",ret,1,&KNotifyRemotePartyInfo);

 			}

 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,remotenumber);

 		if(ret!=KErrNone)

 			{

 			LOGPARSERR("remotenumber",ret,2,&KNotifyRemotePartyInfo);

 			}

 		iNotifyRemotePartyInfoTimer->iDelay = delay;

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EDirectionUnknown;

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iCallingName.Copy(callingname);

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iTelNumber.Copy(remotenumber);	

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;					

 		}

 	else

 		{

 		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;

 		}

	LOGDATA1("...Finished parsing Data Call config parameters...");

	}

CSimDataCall::~CSimDataCall()

/**

 * Destroy all the objects constructed.

 * CSimTimer and CSimSysAgent objects are destroyed here

 */