--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/simtsy/src/CSimVoiceCall.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1171 @@
+// 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 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 "Simlog.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
+*/
+	{
+	LOGVOICE1("Starting to parse Voice Call config parameters...");
+	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)
+			{
+			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;
+		}
+	
+	LOGVOICE1("...Finished parsing Voice Call config parameters...");
+	}
+
+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
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::Dial");
+	// 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)
+			{
+			LOGVOICE1("<<CSimVoiceCall::Dial request from Etel 3rd Party client.");
+			}
+		}
+
+	iDialRequestHandle=aTsyReqHandle;
+	TInt ret;
+	ret = ActionEvent(ECallEventDial,KErrNone);
+	LOGVOICE1("<<CSimVoiceCall::Dial");
+	return ret;
+	}
+	
+TInt CSimVoiceCall::DialCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+/**
+* Cancels a dial Request
+*
+* @param aTsyReqHandle
+* @return KErrNone if successfully cancelled
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::DialCancel");
+	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;
+		}
+	LOGVOICE1("<<CSimVoiceCall::DialCancel");
+	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
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::DialISV");
+	// 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)
+			{
+			LOGVOICE1("<<CSimVoiceCall::Dial request from Etel 3rd Party client.");
+			}
+		}
+
+	iDialRequestHandle=aTsyReqHandle;
+	TInt ret;
+	ret = ActionEvent(ECallEventDial,KErrNone);
+	LOGVOICE1("<<CSimVoiceCall::DialISV");
+	return ret;
+	}
+
+TInt CSimVoiceCall::DialISVCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+/**
+* Cancels an EtelISV originated dial Request
+*
+* @param aTsyReqHandle
+* @return KErrNone if successfully cancelled
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::DialISVCancel");
+	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;
+		}
+	LOGVOICE1("<<CSimVoiceCall::DialISVCancel");
+	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
+*/
+	{
+	LOGVOICE3(">>CSimVoiceCall::AnswerIncomingCall  0x%08x, state %d entry ",this,iState);
+	
+	//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)
+			{
+			LOGVOICE1("<<CSimVoiceCall::AnswerIncomingCall request from Etel 3rd Party client.");
+			}
+		}
+	
+	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);		
+		}
+	LOGVOICE3("<<CSimVoiceCall::AnswerIncomingCall  0x%08x, state %d exit",this,iState);
+	return ret;
+	}
+
+TInt CSimVoiceCall::AnswerIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+/**
+* Cancels a AnswerIncomingCall Request
+*
+* @param aTsyReqHandle
+* @return KErrNone if successfully cancelled
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::AnswerIncomingCallCancel");
+	if(iAnswerIncomingCall.iNotifyPending)
+		{
+		iAnswerIncomingCall.iNotifyPending=EFalse;
+		iLine->ResetAutoAnswerCallObject(this);
+		ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel);
+		}
+	LOGVOICE1("<<CSimVoiceCall::AnswerIncomingCallCancel");
+	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
+*/
+	{
+	LOGVOICE3(">>CSimVoiceCall::AnswerIncomingCallISV  0x%08x, state %d entry ",this,iState);
+	
+	//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)
+			{
+			LOGVOICE1("<<CSimVoiceCall::AnswerIncomingCallISV request from Etel 3rd Party client.");
+			}
+		}
+	
+	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(leaveValue, ret=ChangeStateL(RMobileCall::EStatusRinging,EFalse,EFalse));
+			if (leaveValue != KErrNone)
+				{
+				return leaveValue;
+				}
+
+			if (ret == KErrNone)
+                {
+				ret = ActionEvent(ECallEventAnswerIncoming,KErrNone);		
+	 		    }		
+		}
+	LOGVOICE3("<<CSimVoiceCall::AnswerIncomingCallISV  0x%08x, state %d exit",this,iState);
+	return ret;
+	}
+
+TInt CSimVoiceCall::AnswerIncomingCallISVCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+/**
+* Cancels an EtelISV originated AnswerIncomingCall Request
+*
+* @param aTsyReqHandle
+* @return KErrNone if successfully cancelled
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::AnswerIncomingCallISVCancel");
+	if(iAnswerIncomingCall.iNotifyPending)
+		{
+		iAnswerIncomingCall.iNotifyPending=EFalse;
+		iLine->ResetAutoAnswerCallObject(this);
+		ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel);
+		}
+	LOGVOICE1("<<CSimVoiceCall::AnswerIncomingCallISVCancel");
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::Connect(const TTsyReqHandle aTsyReqHandle,const TDesC8* /*aCallParams*/)
+	{
+	ReqCompleted(aTsyReqHandle,KErrNotSupported);
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::ConnectCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	ReqCompleted(aTsyReqHandle,KErrNotSupported);
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::HangUp(const TTsyReqHandle aTsyReqHandle)
+/**
+* Process a client's HangUp request.
+*
+* @param aTsyReqHandle
+* @return KErrNone
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::HangUp");
+	iHangUpRequestHandle=aTsyReqHandle;
+	TInt ret=ActionEvent(ECallEventHangUp,KErrNone);
+	if(ret!=KErrNone)
+		ReqCompleted(aTsyReqHandle,ret);
+	LOGVOICE1("<<CSimVoiceCall::HangUp");
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::HangUpCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+/**
+* Cancels a HangUp Request
+*
+* @param aTsyReqHandle
+* @return KErrNone if successfully cancelled
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::HangUpCancel");
+	switch(iState)
+		{
+	case RMobileCall::EStatusIdle:
+		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.
+		break;
+
+	case RMobileCall::EStatusDisconnecting:
+		iTimer->DoCancel();
+		// Can ignore for cancel
+		TInt err;
+		err = KErrNone;
+		TRAP(err, (void)ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse));
+		if (err != KErrNone)
+			{
+			ReqCompleted(iHangUpRequestHandle, err);
+			}
+		else
+			{
+			ReqCompleted(iHangUpRequestHandle, KErrCancel);
+			}
+		break;
+
+	default:
+		break;
+		}
+	LOGVOICE1("<<CSimVoiceCall::HangUpCancel");
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::RelinquishOwnership()
+	{
+	return KErrNotSupported;
+	}
+
+TInt CSimVoiceCall::GetBearerServiceInfo(const TTsyReqHandle aTsyReqHandle,RCall::TBearerService* /*aBearerService*/)
+/**
+* Retrieves the bearer service info
+* Not supported for voice calls
+*/
+	{
+	ReqCompleted(aTsyReqHandle,KErrNotSupported);
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::GetCallParams(const TTsyReqHandle aTsyReqHandle, TDes8* /*aParams*/)
+/**
+* Retrives the call parameters
+* Not supported for voice calls
+*/
+	{
+	ReqCompleted(aTsyReqHandle,KErrNotSupported);
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::LoanDataPort(const TTsyReqHandle,RCall::TCommPort*)
+/**
+* Loans the comm port.
+* This is a data call specific request so not supported here.
+*/
+	{
+	return KErrNotSupported;
+	}
+/**
+* Cancels the LoanDataPort request.
+* This is a data call specific request so not supported here.
+*/
+
+TInt CSimVoiceCall::LoanDataPortCancel(const TTsyReqHandle)
+	{
+	return KErrNotSupported;
+	}
+
+TInt CSimVoiceCall::RecoverDataPort(const TTsyReqHandle)
+/**
+* Recovers the comm port.
+* This is a data call specific request so not supported here.
+*/
+	{
+	return KErrNotSupported;
+	}
+
+TInt CSimVoiceCall::Hold(const TTsyReqHandle aReqHandle)
+/**
+ * Put the call on hold.
+ * @param aReqHandle	The request handle associated with this call.
+ * @return TInt			Standard error value.
+ */
+	{
+	if(iState!=RMobileCall::EStatusConnected)
+		{
+		ReqCompleted(aReqHandle,KErrEtelCallNotActive);
+		return KErrNone;
+		}
+	iHoldResumeRequestHandle=aReqHandle;
+	TInt ret=ActionEvent(ECallEventHold,KErrNone);
+	return ret;
+	}
+
+TInt CSimVoiceCall::HoldCancel(const TTsyReqHandle)
+/**
+ * Cancel a Hold request.  Since hold is completed synchronously, this function is empty.
+ */
+	{
+	return KErrNone;
+	}
+	
+/**
+ * Cancel a NotifyConnectConfirmation request. It is possible to cancel
+ * a pending notification if the client did not issue a Dial request.
+ * @param aReqHandle	The request handle associated with this call.
+ */
+TInt CSimVoiceCall::NotifyConnectConfirmationCancel(const TTsyReqHandle aReqHandle)
+	{
+	if (iNotifyConnectConfirmReqHandle==aReqHandle)
+		{
+		iNotifyConnectConfirmReqHandle = NULL;
+		}
+	ReqCompleted(aReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+/**
+ * Resume a pending MO Connection.
+ * @param aReqHandle	The request handle associated with this call.
+ * @param aConnectContinue	Boolean to indicate whether to continue/terminate 
+ *							the call connection.
+ * @return TInt			Standard error value.
+ */
+TInt CSimVoiceCall::ResumeConnect(const TTsyReqHandle aReqHandle, const TBool * aConnectContinue)
+	{
+	TInt ret=KErrNone;
+	
+	if(iWaitForConnectConfirm)
+		{
+		// synchronous operation for either case
+		if (*aConnectContinue)
+			{
+			// okay to continue, initiate dialing, this will
+			// change the state
+			ret=ActionEvent(ECallEventConnectContinue,KErrNone);
+			}
+		else
+			{
+			// terminate the call...
+	
+			// there must be a dial request previously issue,
+			// but we never send the dial request down to call-stack,
+			// and we did not invoke the dial timer, so it will
+			// never expire, so we complete the dial request here
+			ReqCompleted(iDialRequestHandle,KErrNone);
+			}
+			
+		// complete the resume request
+		ReqCompleted(aReqHandle,ret);
+		}
+	else
+		{
+		// client did not issue dial request previously, this request
+		// is received in the wrong state, reject this request
+		ReqCompleted(aReqHandle,KErrAccessDenied);
+		}
+	return ret;
+	}
+	
+/**
+ * Cancel a ResumeConnect request.  Since resume is completed synchronously, this function is empty.
+ */
+TInt CSimVoiceCall::ResumeConnectCancel(const TTsyReqHandle)
+	{
+	return KErrNone;
+	}
+
+
+TInt CSimVoiceCall::Resume(const TTsyReqHandle aReqHandle)
+/**
+ * Put the call on resume.
+ * @param aReqHandle	The request handle associated with this call.
+ * @return TInt			Standard error value.
+ */
+	{
+	if(iState!=RMobileCall::EStatusHold)
+		{
+		ReqCompleted(aReqHandle,KErrAccessDenied);
+		return KErrNone;
+		}
+	iHoldResumeRequestHandle=aReqHandle;
+	TInt ret=ActionEvent(ECallEventResume,KErrNone);
+	return ret;
+	}
+
+
+TInt CSimVoiceCall::ResumeCancel(const TTsyReqHandle)
+/**
+ * Cancel a Resume request.  Since resume is completed synchronously, this function is empty.
+ */
+	{
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::Swap(const TTsyReqHandle aReqHandle)
+/**
+ * If the call is active, put it on hold.  If its on hold, resume it.
+ * @param aReqHandle	The request handle associated with this call.
+ * @return TInt			Standard error value.
+ */
+	{
+	TCallEvent event;
+	if(iState==RMobileCall::EStatusConnected)
+		{
+		event=ECallEventHold;		
+		}
+	else if(iState==RMobileCall::EStatusHold)
+		{	
+		event=ECallEventResume;
+		}
+	else
+		{
+		ReqCompleted(aReqHandle,KErrEtelCallNotActive);
+		return KErrNone;
+		}
+
+	iHoldResumeRequestHandle=aReqHandle;
+	TInt ret=ActionEvent(event,ECallEventSwap);	
+	return ret;
+	}
+
+TInt CSimVoiceCall::SwapCancel(const TTsyReqHandle)
+/**
+ * Cancel a Swap request.  Since swap is completed synchronously, this function is empty.
+ */
+	{
+	return KErrNone;
+	}
+
+TInt CSimVoiceCall::ActionEvent(TCallEvent aEvent,TInt aOtherArgument)
+/**
+* Entry point when an event has occured that may advance the state machine.
+* The aEvent parameter describes the event.
+*
+* This function contains the main state machine for the voice call.  The outer layer
+* switches on the event type.  Where appropriate, there are inner layer switches
+* or conditional statements to handle the different responses that may be required to
+* the same event occurring in different states.
+*
+* @param aEvent The Call event to handle
+* @return value represents the error state caused by the attempted state machine jump.
+*/
+	{
+	TInt ret=KErrNone;
+	__ASSERT_ALWAYS(iState!=RMobileCall::EStatusUnknown,SimPanic(ECallStatusUnknownIllegal));
+	__ASSERT_ALWAYS(aEvent!=ECallEventNtRasConnected,SimPanic(ECallEventIllegal));
+	LOGVOICE3(">>CSimVoiceCall::ActionEvent 0x%08x %d",this,iState);
+
+	switch(aEvent)
+		{
+	case ECallEventDial:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventDial]");
+		if(iState==RMobileCall::EStatusIdle)
+			{			
+			TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDialling,EFalse,EFalse));
+			if(ret==KErrNone)
+				iTimer->Start(iDiallingPause,this);
+			}
+		else
+			return KErrEtelCallAlreadyActive;
+		break;
+
+	case ECallEventHangUp:
+		{
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventHangUp]");
+		switch(iState)
+			{
+		case RMobileCall::EStatusDialling:
+		case RMobileCall::EStatusRinging:
+		case RMobileCall::EStatusAnswering:
+		case RMobileCall::EStatusConnecting:
+		case RMobileCall::EStatusConnected:
+		case RMobileCall::EStatusHold:
+			TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse));
+			if(ret==KErrNone)
+				iTimer->Start(iDisconnectingPause,this);
+			if(iSimDtmf)
+				{
+				iSimDtmf->CallClosureCallback();
+				iSimDtmf=NULL;
+				}
+			break;
+		default:
+			return KErrEtelCallNotActive;
+			}
+		}
+		break;
+
+	case ECallEventIncomingCall:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventIncomingCall]");
+		if(iState==RMobileCall::EStatusIdle)
+			{
+			if(iAnswerIncomingCall.iNotifyPending)
+				{
+				TRAP(ret,	 ret=ProcessAnswerIncomingCallL());
+				}
+			else
+				{
+				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusRinging,EFalse,EFalse));
+				if(ret!=KErrNone)
+					return ret;
+				}
+			}
+		else
+			return KErrEtelCallAlreadyActive;
+		break;
+
+	case ECallEventAnswerIncoming:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventAnswerIncoming]");
+		if(iState==RMobileCall::EStatusRinging)
+			{
+			TRAP(ret, ret=ProcessAnswerIncomingCallL());
+			if(ret!=KErrNone)
+				{
+				return ret;
+				}
+			}
+		else
+			SimPanic(EIllegalStateInconsistancy);		// This is checked before calling ActionEvent
+		break;
+
+	case ECallEventRemoteHangup:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventRemoteHangup]");
+		if(iState==RMobileCall::EStatusConnected)
+			{
+			TRAP(ret, ret=ProcessRemoteHangupL());
+			if(ret!=KErrNone)
+				{
+				return ret;
+				}
+			}
+		else
+			SimPanic(EIllegalStateInconsistancy);		// This is checked before calling ActionEvent
+		break;
+
+	case ECallEventTimeOut:
+			{
+			LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventTimeOut]");
+			switch(iState)
+				{
+			case RMobileCall::EStatusDialling:
+				LOGVOICE1(">>CSimVoiceCall::State = [EStatusDialling]");
+				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnecting,EFalse,EFalse));
+				if(ret==KErrNone)
+					iTimer->Start(iConnectingPause,this);
+				return ret;
+			
+			case RMobileCall::EStatusConnecting:
+				LOGVOICE1(">>CSimVoiceCall::State = [EStatusConnecting]");
+				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse));
+				UpdateRemotePartyInfoDirection(RMobileCall::EStatusConnecting);
+				ReqCompleted(iDialRequestHandle,ret);
+				return ret;
+				
+			case RMobileCall::EStatusDisconnecting:
+				LOGVOICE1(">>CSimVoiceCall::State = [EStatusDisconnecting]");
+				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));
+				ReqCompleted(iHangUpRequestHandle,ret);
+				return ret;
+				
+			case RMobileCall::EStatusAnswering:
+				LOGVOICE1(">>CSimVoiceCall::State = [EStatusAnswering]");
+				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse));
+				UpdateRemotePartyInfoDirection(RMobileCall::EStatusAnswering);
+				ReqCompleted(iAnswerIncomingCall.iNotifyHandle,ret);
+				return ret;
+
+			default:
+				break;
+				}
+			}
+		break;
+	case ECallEventHold:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventHold]");
+		__ASSERT_ALWAYS(iState==RMobileCall::EStatusConnected,SimPanic(EIllegalStateInconsistancy));
+		TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusHold,aOtherArgument == ECallEventSwap,EFalse));
+		if (ret == KErrNone)
+			ReqCompleted(iHoldResumeRequestHandle,ret);
+		break;
+
+	case ECallEventResume:
+		LOGVOICE1(">>CSimVoiceCall::ActionEvent = [ECallEventResume]");
+		__ASSERT_ALWAYS(iState==RMobileCall::EStatusHold,SimPanic(EIllegalStateInconsistancy));
+		TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,aOtherArgument == ECallEventSwap,EFalse));
+		if (ret == KErrNone)
+			ReqCompleted(iHoldResumeRequestHandle,ret);
+		break;
+
+	case ECallEventConnectContinue:
+		SimPanic(EIllegalVoiceCallEvent);	// All other events not legal for voice call.
+		break;
+	default:
+		SimPanic(EIllegalVoiceCallEvent);	// All other events not legal for voice call.
+		break;
+		}
+
+	return ret;
+	}
+
+
+void CSimVoiceCall::TimerCallBack(TInt /*aId*/)
+/**
+* Timer callback function.  When the timer goes off, it will call back into this
+* function for further processing.
+*/
+	{
+	LOGVOICE1(">>CSimVoiceCall::TimerCallBack");
+	TInt ret=ActionEvent(ECallEventTimeOut,KErrNone);
+	__ASSERT_ALWAYS(ret==KErrNone,SimPanic(ETimeOutEventActionFailed));
+	LOGVOICE1("<<CSimVoiceCall::TimerCallBack");
+	}
+
+TInt CSimVoiceCall::ProcessAnswerIncomingCallL()
+/**
+* Answers an Incoming Call.
+* First the call state must be changed to "answering", then the flag indicating
+* that an answer incoming call request is no longer pending.  Finally, a new
+* call object must be assigned to receive the details of the next incoming call.
+*/
+	{
+	LOGVOICE3(">>CSimVoiceCall::ProcessAnswerIncomingCall %d",iState,this);
+	TInt ret=ChangeStateL(RMobileCall::EStatusAnswering,EFalse,EFalse);
+	if(ret!=KErrNone)
+		return ret;
+	iTimer->Start(iAnswerIncomingPause,this);
+	iAnswerIncomingCall.iNotifyPending=EFalse;
+	iLine->ResetAutoAnswerCallObject(this);
+	LOGVOICE1("<<CSimVoiceCall::ProcessAnswerIncomingCall");
+	return ret;
+	}
+
+TInt CSimVoiceCall::ProcessRemoteHangupL()
+/**
+* Hangs up a call remotely.
+* First the call state must be changed to "disconnecting", then the flag indicating
+* that a remote hangup request is no longer pending.  Finally, a new
+* call object must be assigned to receive the next remote hangup request.
+*/
+	{
+	LOGVOICE3(">>CSimVoiceCall::ProcessRemoteHangupL %d",iState,this);
+	TInt ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse);
+	if(ret!=KErrNone)
+		return ret;
+	iTimer->Start(iRemoteHangupPause,this);
+	iLine->ResetRemoteHangupCallObject(this);
+	LOGVOICE1("<<CSimVoiceCall::ProcessRemoteHangupL");
+	return ret;
+	}
+
+void CSimVoiceCall::SetDtmfSession(CSimDtmf* aSimDtmf)
+/**
+ * Set the DTMF session pointer.
+ */
+	{
+	__ASSERT_ALWAYS(iState==RMobileCall::EStatusConnected,SimPanic(EIllegalDtmfReq));
+	iSimDtmf=aSimDtmf;
+	}
+
+CSimDtmf* CSimVoiceCall::GetDtmfSession()
+/**
+ * Retrieve the DTMF session pointer.
+ */
+	{
+	return iSimDtmf;
+	}
+
+
+TUint CSimVoiceCall::Caps()
+/**
+ * Return the current capabilities of this call.
+ * @return TUint	Current call capabilities.
+ */
+	{
+	TUint caps=RCall::KCapsVoice;
+	if(iState!=RMobileCall::EStatusIdle)
+		{
+		if(iState==RMobileCall::EStatusConnected)
+			{
+			caps |= RCall::KCapsHangUp;
+			// If there is only a single call and its state is connected then the hold capability 
+			// should be set.
+			// If there is more than one call then only the swap capability should be set as hold 
+			// and resume apply only to single calls.
+		
+			TInt i=0;
+			TBool singleCall = ETrue;
+			TInt count=	iLine->iCalls->Count();
+		
+			while(singleCall && i<count)
+				{
+ 				if(iLine->iCalls->At(i) != this && (iLine->iCalls->At(i)->iState == RMobileCall::EStatusConnected || iLine->iCalls->At(i)->iState == RMobileCall::EStatusHold))
+					singleCall = EFalse;
+				i++;
+				}	
+			
+			if (singleCall)
+				caps |= RMobileCall::KCapsHold;
+			// Swap capability is applicable to single and multiple call
+			// scenarios
+			caps |= RMobileCall::KCapsSwap;
+			}
+		else if(iState==RMobileCall::EStatusHold)
+			{
+			caps |= RCall::KCapsHangUp;
+
+			TBool otherConnected = EFalse;
+			TInt count=	iLine->iCalls->Count();
+			TInt i=0;
+			while (!otherConnected && i<count)
+				{
+ 				if(iLine->iCalls->At(i) != this && (iLine->iCalls->At(i)->iState == RMobileCall::EStatusConnected || iLine->iCalls->At(i)->iState == RMobileCall::EStatusHold))
+					otherConnected = ETrue;
+				i++;
+				}	
+			if(otherConnected)
+				{
+				caps |= RMobileCall::KCapsSwap;
+				}
+			else
+				{
+				caps |= RMobileCall::KCapsResume;
+				caps |= RMobileCall::KCapsSwap;
+				}					
+			}
+		else if (iState==RMobileCall::EStatusRinging)
+			{
+			if((iLine->IsAnswerCallObjectSpare()))
+				caps |= RCall::KCapsAnswer;	
+			}
+		}
+	else
+		{
+		if(iLine->iState==RMobileCall::EStatusIdle || iLine->iState==RMobileCall::EStatusHold)
+			{
+			caps |= RCall::KCapsDial;
+			if((iLine->IsAnswerCallObjectSpare()))
+				caps |= RCall::KCapsAnswer;
+			}
+		else if (iLine->iState==RMobileCall::EStatusRinging)
+			{
+			if((iLine->IsAnswerCallObjectSpare()))
+				caps |= RCall::KCapsAnswer;			
+			}
+		}
+	return caps;
+	}
+
+void CSimVoiceCall::UpdateRemotePartyInfoDirection(RMobileCall::TMobileCallStatus aPreviousStatus)
+/**
+Update the direction of the call for the remote party info member
+*/
+	{
+	if(iNotifyRemotePartyInfoTimer && iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus != RMobileCall::ERemoteIdentityUnknown)	
+		{
+		if(aPreviousStatus == RMobileCall::EStatusAnswering)
+			iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EMobileTerminated;
+		else
+			iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EMobileOriginated;
+		}			
+	}