// 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 Voice 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 "CSimVoiceCall.h"

#include "CSimPhone.h"

#include "CSimDtmf.h"

#include "CSimTsyMode.h"

CSimVoiceCall* CSimVoiceCall::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 CSimVoiceCall  pointer to the voice call object created

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

*/

	{

	CSimVoiceCall* voiceCall=new(ELeave) CSimVoiceCall(aLine,aName,aPhone);

	TCleanupItem newCallVoiceClose(CloseCall,voiceCall);

	CleanupStack::PushL(newCallVoiceClose);

	voiceCall->ConstructL();

	CleanupStack::Pop();

	return voiceCall;

	}

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

	: CSimCall(aLine,aName,aPhone)

/**

* Trivial constructor. Calls CSimCall to initialise its members

*/

	{

	}

void CSimVoiceCall::ConstructL()

/**

* Second phase of 2-Phase Constructor

* Retrieves all the pausing duration tags from the config file

*

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

*/

	{

	iCaps=Caps();

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

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

	CSimCall::ConstructL();

	//If present read in remote party info tag

	TPtrC8 callingname, remotenumber;

	TInt delay=0;

	const CTestConfigItem* item=NULL;

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

	TInt ret;

	if (item)

		{

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

		if(ret!=KErrNone)

			{

			}

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

		if(ret!=KErrNone)

			{

			}

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

		if(ret!=KErrNone)

			{

			}

		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;

		}

	}

CSimVoiceCall::~CSimVoiceCall()

/**

* Destroy all the objects constructed.

* CSimTimer and CSimSysAgent objects are destroyed here

*/

	{

	delete iTimer;

	if(iAnswerIncomingCall.iNotifyPending)

		iLine->ResetAutoAnswerCallObject(this);

	}

TInt CSimVoiceCall::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,const TDataPackage& aPackage)

/**

* ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request 

* for the TSY to process

* A request handle, request type and request data are passed to the TSY

*

* @param aTsyReqHandle

* @param aIpc IPc number representing the request

* @param aPackage data for the request

* @return KErrNone

*/

	{

	TAny* dataPtr=aPackage.Ptr1();

	// The request data has to extracted from TDataPackage and the TAny* pointers have to

	// be "cast" to the expected request data type

	switch (aIpc)

		{

	//

	// No Flow Control NOR Multiple Completion

	//

	case EMobileCallGetMobileCallCaps:

		return GetMobileCallCaps(aTsyReqHandle,aPackage.Des1n());

	case EMobileCallGetMobileCallStatus:

		return GetMobileCallStatus(aTsyReqHandle,

			REINTERPRET_CAST(RMobileCall::TMobileCallStatus*,dataPtr));

	case EMobileCallGetMobileCallInfo:

		return GetMobileCallInfo(aTsyReqHandle,aPackage.Des1n());

	case EMobileCallDialEmergencyCall:

		return DialEmergencyCall(aTsyReqHandle,aPackage.Des1u());

	case EMobileCallHold:

		return Hold(aTsyReqHandle);

	case EMobileCallResume:

		return Resume(aTsyReqHandle);

	case EMobileCallSwap:

		return Swap(aTsyReqHandle);

	case EMobileCallDialISV:

		return DialISV(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());

	case EMobileCallAnswerISV:

		TInt retVal;

		TRAPD(errVal, retVal=AnswerIncomingCallISVL(aTsyReqHandle, aPackage.Des1n()));

		if (errVal != KErrNone)

			{

			return errVal;

			}

		else

			{

			return retVal;	

			}

	//

	// Multiple Completion Services with Immediate Server Repost

	// (Usually Notifications)

	//

	case EMobileCallNotifyMobileCallStatusChange:

		return NotifyMobileCallStatusChange(aTsyReqHandle,

			REINTERPRET_CAST(RMobileCall::TMobileCallStatus*, dataPtr));

	case EMobileCallNotifyMobileCallCapsChange:

		return NotifyMobileCallCapsChange(aTsyReqHandle, aPackage.Des1n());

	case EMobileCallNotifyRemotePartyInfoChange:

		return NotifyRemotePartyInfoChange(aTsyReqHandle, aPackage.Des1n());		

	default:

		break;

		}

	return KErrNotSupported;

	}

TInt CSimVoiceCall::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

/**

 * Cancel an outstanding request.

 * @param aIpc The IPC number of the request that must be cancelled.  Note: this is not the

 *             IPC number of the cancel request itself.

 * @param aTsyReqHandle The TSY Request Handle of the request to be cancelled.

 */

	{

	switch(aIpc)

		{

	case EMobileCallNotifyMobileCallStatusChange:

		return NotifyMobileCallStatusChangeCancel(aTsyReqHandle);

	case EMobileCallNotifyMobileCallCapsChange:

		return NotifyMobileCallCapsChangeCancel(aTsyReqHandle);

	case EMobileCallDialEmergencyCall:

		return DialEmergencyCallCancel(aTsyReqHandle);

	case EMobileCallHold:

		return HoldCancel(aTsyReqHandle);

	case EMobileCallResume:

		return ResumeCancel(aTsyReqHandle);

	case EMobileCallSwap:

		return SwapCancel(aTsyReqHandle);

	case EMobileCallNotifyRemotePartyInfoChange:

		return NotifyRemotePartyInfoChangeCancel();

	case EMobileCallDialISV:

		return DialISVCancel(aTsyReqHandle);

	case EMobileCallAnswerISV:

		return AnswerIncomingCallISVCancel(aTsyReqHandle);       

	default:

		break;

		}

	return CCallBase::CancelService(aIpc,aTsyReqHandle);

	}

TInt CSimVoiceCall::DialEmergencyCall(const TTsyReqHandle aTsyReqHandle,TDesC* aTelNumber)

/**

* Process a client's emergency call request.

*

* @param aTsyReqHandle

* @param aTelNumber The telephone number to dial

* @return KErrNone

*/

	{

	return Dial(aTsyReqHandle,NULL,aTelNumber);

	}

TInt CSimVoiceCall::DialEmergencyCallCancel(const TTsyReqHandle aTsyReqHandle)

/**

* Cancels an emergency call request.

*

* @param aTsyReqHandle

* @return KErrNone if successfully cancelled

*/

	{

	return DialCancel(aTsyReqHandle);

	}

TInt CSimVoiceCall::Dial(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams,TDesC* /*aTelNumber*/)

/**

* Process a client's dial request.

*

* @param aTsyReqHandle

* @param aCallParams  the call parameters

* @param aTelNumber The telephone number to dial

* @return KErrNone

*/

	{

	// Note: The telephone number and call parameters should be validated against config file

	//       values here.

	//see where the dial request has orignated from

	if(aCallParams)

		{

		RCall::TCallParamsPckg* callparamsPckg=reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>(aCallParams));

		RCall::TCallParams& callparams=(*callparamsPckg)();

		if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)

			{

			}

		}

	iDialRequestHandle=aTsyReqHandle;

	TInt ret;

	ret = ActionEvent(ECallEventDial,KErrNone);

	return ret;

	}

TInt CSimVoiceCall::DialCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancels a dial Request

*

* @param aTsyReqHandle

* @return KErrNone if successfully cancelled

*/

	{

	switch(iState)

		{

	case RMobileCall::EStatusIdle:

		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.

		break;

	case RMobileCall::EStatusDialling:

	case RMobileCall::EStatusConnecting:

		iTimer->DoCancel();

		// Can ignore for cancel

		TInt err;

		err = KErrNone;

		TRAP(err, (void)ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));

		if (err != KErrNone)

			{

			ReqCompleted(iDialRequestHandle, err);

			}

		else

			{

			ReqCompleted(iDialRequestHandle, KErrCancel);

			}

		break;

	case RMobileCall::EStatusConnected:

		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.

		break;

	default:

		break;

		}

	return KErrNone;

	}

TInt CSimVoiceCall::DialISV(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams,TDesC* /*aTelNumber*/)

/**

* Process an EtelISV client's dial request.

*

* @param aTsyReqHandle

* @param aCallParams  the call parameters

* @param aTelNumber The telephone number to dial

* @return KErrNone

*/

	{

	// Note: The telephone number and call parameters should be validated against config file

	//       values here.

	//see where the dial request has orignated from

	if(aCallParams)

		{

		RCall::TCallParamsPckg* callparamsPckg=reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>(aCallParams));

		RCall::TCallParams& callparams=(*callparamsPckg)();

		if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)

			{

			}

		}

	iDialRequestHandle=aTsyReqHandle;

	TInt ret;

	ret = ActionEvent(ECallEventDial,KErrNone);

	return ret;

	}

TInt CSimVoiceCall::DialISVCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancels an EtelISV originated dial Request

*

* @param aTsyReqHandle

* @return KErrNone if successfully cancelled

*/

	{

	switch(iState)

		{

	case RMobileCall::EStatusIdle:

		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.

		break;

	case RMobileCall::EStatusDialling:

	case RMobileCall::EStatusConnecting:

		iTimer->DoCancel();

		// Can ignore for cancel

		TInt err;

		err = KErrNone;

		TRAP(err, (void)ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));

		if (err != KErrNone)

			{

			ReqCompleted(iDialRequestHandle, err);

			}

		else

			{

			ReqCompleted(iDialRequestHandle, KErrCancel);

			}

		break;

	case RMobileCall::EStatusConnected:

		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.

		break;

	default:

		break;

		}

	return KErrNone;

	}

TInt CSimVoiceCall::AnswerIncomingCall(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams)

/**

* Register a client's interest in answering the next incoming call.

* First register interest in incoming calls with the line, then, if a call

* is already ringing, start the answer procedure.

*

* @param aTsyReqHandle

* @param aCallParams  the call parameters

* @return KErrNone

*/

	{

	//see where the answer request has orignated from

	if(aCallParams)

		{

		RCall::TCallParamsPckg* callparamsPckg=reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>(aCallParams));

		RCall::TCallParams& callparams=(*callparamsPckg)();

		if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)

			{

			}

		}

	TInt ret=iLine->SetAutoAnswerCallObject(this);

	if(ret!=KErrNone)

		{

		ReqCompleted(aTsyReqHandle,ret);

		return KErrNone;

		}

	iAnswerIncomingCall.iNotifyPending=ETrue;

	iAnswerIncomingCall.iNotifyHandle=aTsyReqHandle;

	if(iState==RMobileCall::EStatusRinging)

			ret = ActionEvent(ECallEventAnswerIncoming,KErrNone);	

	else if(iLine->iState==RMobileCall::EStatusRinging)

		{		

		TRAPD(errVal, ret=ChangeStateL(RMobileCall::EStatusRinging,EFalse,EFalse));

		if (errVal != KErrNone)

			{

			ret = errVal;

			}

		if(ret==KErrNone)

			ret = ActionEvent(ECallEventAnswerIncoming,KErrNone);		

		}

	return ret;

	}

TInt CSimVoiceCall::AnswerIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancels a AnswerIncomingCall Request

*

* @param aTsyReqHandle

* @return KErrNone if successfully cancelled

*/

	{

	if(iAnswerIncomingCall.iNotifyPending)

		{

		iAnswerIncomingCall.iNotifyPending=EFalse;

		iLine->ResetAutoAnswerCallObject(this);

		ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimVoiceCall::AnswerIncomingCallISVL(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams)

/**

* Register an EtelISV client's interest in answering the next incoming call.

* First register interest in incoming calls with the line, then, if a call

* is already ringing, start the answer procedure.

*

* @param aTsyReqHandle

* @param aCallParams  the call parameters

* @return KErrNone

*/

	{

	//see where the answer request has orignated from

	if(aCallParams)

		{

		RCall::TCallParamsPckg* callparamsPckg=reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>(aCallParams));

		RCall::TCallParams& callparams=(*callparamsPckg)();

		if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)

			{