--- /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;
+ }
+ }