--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelmultimode/DTsy/mmtsycall.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1857 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "mmtsy.h"
+#include "testdef.h"
+#include "ETELMM.H"
+#include <et_clsvr.h>
+#include "Dmmlog.h"
+
+//#define ASYNC_TIMEOUT 300000 // 0.3s
+
+//
+// CCallDMmTsy
+//
+CCallDMmTsy* CCallDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac)
+ {
+ CCallDMmTsy* call=new(ELeave) CCallDMmTsy(aPhone,aFac);
+ CleanupStack::PushL(call);
+ call->ConstructL();
+ CleanupStack::Pop();
+ return call;
+ }
+
+CCallDMmTsy::CCallDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac)
+ :CCallDummyBase(aFac), iPhone(aPhone)
+ {}
+
+void CCallDMmTsy::ConstructL()
+ {
+ CCallDummyBase::ConstructL();
+ LOGTEXT(_L8("CCallDMmTsy created"));
+ }
+
+CCallDMmTsy::~CCallDMmTsy()
+ {
+ LOGTEXT(_L8("CCallDMmTsy destroyed"));
+ }
+
+CTelObject* CCallDMmTsy::OpenNewObjectByNameL(const TDesC& aName)
+ {
+ // only fax objects can be opened from call objects
+ if (aName.Compare(_L("FAX"))==KErrNone)
+ return REINTERPRET_CAST(CTelObject*, CFaxDMmTsy::NewL(FacPtr()));
+ else
+ return NULL;
+ }
+
+CTelObject* CCallDMmTsy::OpenNewObjectL(TDes& /*aNewName*/)
+ {
+ // opening fax without a name is not supported
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+CTelObject::TReqMode CCallDMmTsy::ReqModeL(const TInt aIpc)
+ {
+ // ReqModeL is called from the server's CTelObject::ReqAnalyserL
+ // in order to check the type of request it has
+
+ // The following are example request types for this dummy TSY
+ // All TSYs do not have to have these request types but they have been given
+ // "sensible" values in this test code
+
+ CTelObject::TReqMode ret=0;
+ switch (aIpc)
+ {
+//
+// No Flow Control NOR Multiple Completion
+//
+ case EMobileCallGetMobileCallCaps:
+ case EMobileCallGetMobileCallStatus:
+ case EMobileCallGetMobileCallInfo:
+ case EMobileCallGetMobileDataCallCaps:
+ case EMobileCallGetMobileDataCallRLPRange:
+ case EMobileCallSetDynamicHscsdParams:
+ case EMobileCallGetCurrentHscsdInfo:
+ case EMobileCallSwitchAlternatingCall:
+ case EMobileCallDeflect:
+ case EMobileCallTransfer:
+ case EMobileCallGoOneToOne:
+ case EMobileCallActivateCCBS:
+ case EMobileCallRejectCCBS:
+ case EMobileCallSetPrivacy:
+ case EMobileCallSetTrafficChannel:
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ case EMobileCallGetUUSCaps:
+ case EMobileCallActivateUUS:
+ case EMobileCallSendUUI:
+ case EMobileCallReceiveUUI:
+ case EMobileCallHangupWithUUI:
+ case EMobileCallAnswerWithUUI:
+ case EMobileCallAnswerMultimediaCallAsVoice:
+ case EMobileCallAnswerISV:
+ break;
+//
+// Flow Controlled Services
+//
+ case EMobileCallHold:
+ case EMobileCallResume:
+ case EMobileCallSwap:
+ case EMobileCallDialEmergencyCall:
+ case EMobileCallDialNoFdnCheck:
+ case EMobileCallDialISV:
+ case EMobileCallDialCallControl:
+ ret=KReqModeFlowControlObeyed;
+ break;
+
+//
+// Multiple Completion Services with Immediate Server Repost
+// (Usually Notifications)
+//
+ case EMobileCallNotifyMobileCallStatusChange:
+ case EMobileCallNotifyMobileCallCapsChange:
+ case EMobileCallNotifyCallEvent:
+ case EMobileCallNotifyRemotePartyInfoChange:
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ case EMobileCallNotifyHscsdInfoChange:
+ case EMobileCallNotifyVoiceFallback:
+ case EMobileCallNotifyAlternatingCallSwitch:
+ case EMobileCallNotifyPrivacyConfirmation:
+ case EMobileCallNotifyUUSCapsChange:
+ case EMobileCallNotifyAudioToneEvent:
+ ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
+ break;
+//
+// Not Supported
+//
+ case EMobileCallNotifyMobileCallStatusChangeCancel:
+ case EMobileCallHoldCancel:
+ case EMobileCallResumeCancel:
+ case EMobileCallSwapCancel:
+ case EMobileCallNotifyMobileCallCapsChangeCancel:
+ case EMobileCallNotifyCallEventCancel:
+ case EMobileCallDialEmergencyCallCancel:
+ case EMobileCallGetMobileCallInfoCancel:
+ case EMobileCallNotifyRemotePartyInfoChangeCancel:
+ case EMobileCallNotifyMobileDataCallCapsChangeCancel:
+ case EMobileCallGetMobileDataCallRLPRangeCancel:
+ case EMobileCallSetDynamicHscsdParamsCancel:
+ case EMobileCallSwitchAlternatingCallCancel:
+ case EMobileCallActivateCCBSCancel:
+ case EMobileCallNotifyPrivacyConfirmationCancel:
+ case EMobileCallNotifyTrafficChannelConfirmationCancel:
+ case EMobileCallNotifyVoiceFallbackCancel:
+ case EMobileCallNotifyUUSCapsChangeCancel:
+ case EMobileCallActivateUUSCancel:
+ case EMobileCallSendUUICancel:
+ case EMobileCallReceiveUUICancel:
+ case EMobileCallHangupWithUUICancel:
+ case EMobileCallAnswerWithUUICancel:
+ case EMobileCallDialNoFdnCheckCancel:
+ case EMobileCallDialCallControlCancel:
+ case EMobileCallAnswerMultimediaCallAsVoiceCancel:
+ case EMobileCallNotifyAudioToneEventCancel:
+ case EMobileCallDialISVCancel:
+ case EMobileCallAnswerISVCancel:
+ User::Leave(KErrNotSupported);
+ break;
+
+ default:
+ ret=CCallBase::ReqModeL(aIpc);
+ break;
+ }
+ return ret;
+ }
+
+
+TInt CCallDMmTsy::RegisterNotification(const TInt aIpc)
+ {
+ // RegisterNotification is called when the server recognises that this notification
+ // is being posted for the first time on this sub-session object.
+
+ // It enables the TSY to "turn on" any regular notification messages that it may
+ // receive from the phone
+
+ switch (aIpc)
+ {
+ case EMobileCallNotifyMobileCallStatusChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Call Status Change "));
+ return KErrNone;
+ case EMobileCallNotifyMobileCallCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Call Control Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyCallEvent:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Call Event "));
+ return KErrNone;
+ case EMobileCallNotifyRemotePartyInfoChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Remote Party Info Change "));
+ return KErrNone;
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Data Call Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyHscsdInfoChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Hscsd Info Change "));
+ return KErrNone;
+ case EMobileCallNotifyVoiceFallback:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Voice Fallback "));
+ return KErrNone;
+ case EMobileCallNotifyAlternatingCallSwitch:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Alternating Call Switch "));
+ return KErrNone;
+ case EMobileCallNotifyPrivacyConfirmation:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Privacy Confirmation "));
+ return KErrNone;
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Traffic Channel Confirmation "));
+ return KErrNone;
+ case EMobileCallNotifyUUSCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify UUS Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyAudioToneEvent:
+ LOGTEXT(_L8("CCallDMmTsy: RegisterNotification - Notify Audio Tone Event "));
+ return KErrNone;
+ default:
+ // Unknown or invalid IPC
+ LOGTEXT(_L8("CCallDMmTsy: Register error, unknown IPC"));
+ return KErrNotSupported;
+ }
+ }
+
+TInt CCallDMmTsy::DeregisterNotification(const TInt aIpc)
+ {
+ // DeregisterNotification is called when the server recognises that this notification
+ // will not be posted again because the last client to have a handle on this sub-session
+ // object has just closed the handle.
+
+ // It enables the TSY to "turn off" any regular notification messages that it may
+ // receive from the phone
+
+ switch (aIpc)
+ {
+ case EMobileCallNotifyMobileCallStatusChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Call Status Change "));
+ return KErrNone;
+ case EMobileCallNotifyMobileCallCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Call Control Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyCallEvent:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Call Event "));
+ return KErrNone;
+ case EMobileCallNotifyRemotePartyInfoChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Remote Party Info Change "));
+ return KErrNone;
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Data Call Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyHscsdInfoChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Hscsd Info Change "));
+ return KErrNone;
+ case EMobileCallNotifyVoiceFallback:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Voice Fallback "));
+ return KErrNone;
+ case EMobileCallNotifyAlternatingCallSwitch:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Alternating Call Switch "));
+ return KErrNone;
+ case EMobileCallNotifyPrivacyConfirmation:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Privacy Confirmation "));
+ return KErrNone;
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Traffic Channel Confirmation "));
+ return KErrNone;
+ case EMobileCallNotifyUUSCapsChange:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify UUS Caps Change "));
+ return KErrNone;
+ case EMobileCallNotifyAudioToneEvent:
+ LOGTEXT(_L8("CCallDMmTsy: DeregisterNotification - Notify Audio Tone Event "));
+ return KErrNone;
+ default:
+ // Unknown or invalid IPC
+ LOGTEXT(_L8("CCallDMmTsy: Deregister error, unknown IPC"));
+ return KErrNotSupported;
+ }
+ }
+
+TInt CCallDMmTsy::NumberOfSlotsL(const TInt aIpc)
+ {
+ // NumberOfSlotsL is called by the server when it is registering a new notification
+ // It enables the TSY to tell the server how many buffer slots to allocate for
+ // "repost immediately" notifications that may trigger before clients collect them
+
+ TInt numberOfSlots=1;
+ switch (aIpc)
+ {
+ case EMobileCallNotifyMobileCallStatusChange:
+ case EMobileCallNotifyMobileCallCapsChange:
+ case EMobileCallNotifyCallEvent:
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ case EMobileCallNotifyHscsdInfoChange:
+ case EMobileCallNotifyVoiceFallback:
+ case EMobileCallNotifyAlternatingCallSwitch:
+ case EMobileCallNotifyPrivacyConfirmation:
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ case EMobileCallNotifyUUSCapsChange:
+ case EMobileCallNotifyAudioToneEvent:
+ LOGTEXT(_L8("CCallDMmTsy: Registered with 5 slots"));
+ numberOfSlots=5;
+ break;
+ case EMobileCallNotifyRemotePartyInfoChange:
+
+ LOGTEXT(_L8("CCallDMmTsy: Registered with 1 slot"));
+ break;
+ default:
+ // Unknown or invalid Phone IPC
+ LOGTEXT(_L8("CCallDMmTsy: Number of Slots error, unknown IPC"));
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ return numberOfSlots;
+ }
+
+
+TInt CCallDMmTsy::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
+
+ TAny* dataPtr=aPackage.Ptr1();
+ TAny* dataPtr2=aPackage.Ptr2();
+
+ // 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 EMobileCallGetMobileDataCallCaps:
+ return GetMobileDataCallCaps(aTsyReqHandle, aPackage.Des1n());
+
+ case EMobileCallGetMobileDataCallRLPRange:
+ return GetMobileDataCallRLPRange(aTsyReqHandle,
+ REINTERPRET_CAST(TInt *, dataPtr),
+ aPackage.Des2n());
+
+ case EMobileCallSetDynamicHscsdParams:
+ return SetDynamicHscsdParams(aTsyReqHandle,
+ REINTERPRET_CAST(TInt*,dataPtr),
+ REINTERPRET_CAST(TInt*,dataPtr2));
+
+ case EMobileCallGetCurrentHscsdInfo:
+ return GetCurrentHscsdInfo(aTsyReqHandle,aPackage.Des1n());
+
+ case EMobileCallSwitchAlternatingCall:
+ return SwitchAlternatingCall(aTsyReqHandle);
+
+ case EMobileCallDeflect:
+ return Deflect(aTsyReqHandle,
+ REINTERPRET_CAST(RMobileCall::TMobileCallDeflect*, dataPtr),
+ REINTERPRET_CAST(RMobilePhone::TMobileAddress*, dataPtr2));
+
+ case EMobileCallTransfer:
+ return Transfer(aTsyReqHandle);
+
+ case EMobileCallGoOneToOne:
+ return GoOneToOne(aTsyReqHandle);
+
+ case EMobileCallActivateCCBS:
+ return ActivateCCBS(aTsyReqHandle,
+ REINTERPRET_CAST(TInt*, dataPtr));
+
+ case EMobileCallRejectCCBS:
+ return RejectCCBS(aTsyReqHandle);
+
+ case EMobileCallSetPrivacy:
+ return SetPrivacySetting(aTsyReqHandle,
+ REINTERPRET_CAST(RMobilePhone::TMobilePhonePrivacy*, dataPtr));
+
+ case EMobileCallNotifyPrivacyConfirmation:
+ return NotifyPrivacyConfirmation(aTsyReqHandle,
+ REINTERPRET_CAST(RMobilePhone::TMobilePhonePrivacy*, dataPtr));
+
+ case EMobileCallSetTrafficChannel:
+ return SetTrafficChannel(aTsyReqHandle,
+ REINTERPRET_CAST(RMobileCall::TMobileCallTch*, dataPtr));
+
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ return NotifyTrafficChannelConfirmation(aTsyReqHandle,
+ REINTERPRET_CAST(RMobileCall::TMobileCallTch*,dataPtr));
+
+ case EMobileCallGetUUSCaps:
+ return GetUUSCaps(aTsyReqHandle,
+ REINTERPRET_CAST(TUint32*,dataPtr));
+
+ case EMobileCallActivateUUS:
+ return ActivateUUS(aTsyReqHandle, aPackage.Des1n());
+
+ case EMobileCallSendUUI:
+ return SendUUI(aTsyReqHandle,
+ REINTERPRET_CAST(TInt*,dataPtr), aPackage.Des2u());
+
+ case EMobileCallReceiveUUI:
+ return ReceiveUUI(aTsyReqHandle, aPackage.Des1u());
+
+ case EMobileCallHangupWithUUI:
+ return HangupWithUUI(aTsyReqHandle, aPackage.Des1u());
+
+ case EMobileCallAnswerWithUUI:
+ return AnswerIncomingCallWithUUI(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());
+
+ case EMobileCallAnswerMultimediaCallAsVoice:
+ return AnswerMultimediaCallAsVoice(aTsyReqHandle,
+ aPackage.Des1n(), aPackage.Des2u());
+
+ case EMobileCallAnswerISV:
+ return AnswerIncomingCallISV(aTsyReqHandle, aPackage.Des1n());
+
+//
+// Flow Controlled Services
+//
+ case EMobileCallHold:
+ return Hold(aTsyReqHandle);
+
+ case EMobileCallResume:
+ return Resume(aTsyReqHandle);
+
+ case EMobileCallSwap:
+ return Swap(aTsyReqHandle);
+
+ case EMobileCallDialEmergencyCall:
+ return DialEmergencyCall(aTsyReqHandle, aPackage.Des1u());
+
+ case EMobileCallDialNoFdnCheck:
+ return DialNoFdnCheck(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());
+
+ case EMobileCallDialISV:
+ return DialISV(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());
+
+ case EMobileCallDialCallControl:
+ return DialCallControl(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());
+
+//
+// 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 EMobileCallNotifyCallEvent:
+ return NotifyCallEvent(aTsyReqHandle,
+ REINTERPRET_CAST(RMobileCall::TMobileCallEvent*, dataPtr));
+
+ case EMobileCallNotifyRemotePartyInfoChange:
+ return NotifyRemotePartyInfoChange(aTsyReqHandle, aPackage.Des1n());
+
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ return NotifyMobileDataCallCapsChange(aTsyReqHandle, aPackage.Des1n());
+
+ case EMobileCallNotifyHscsdInfoChange:
+ return NotifyHscsdInfoChange(aTsyReqHandle, aPackage.Des1n());
+
+ case EMobileCallNotifyVoiceFallback:
+ return NotifyVoiceFallback(aTsyReqHandle, aPackage.Des1u());
+
+ case EMobileCallNotifyAlternatingCallSwitch:
+ return NotifyAlternatingCallSwitch(aTsyReqHandle);
+
+ case EMobileCallNotifyUUSCapsChange:
+ return NotifyUUSCapsChange(aTsyReqHandle,
+ REINTERPRET_CAST(TUint32*, dataPtr));
+
+ case EMobileCallNotifyAudioToneEvent:
+ return NotifyAudioToneEvent(aTsyReqHandle, aPackage.Des1n());
+//
+// Cancels
+//
+ case EMobileCallNotifyMobileCallStatusChangeCancel:
+ return NotifyMobileCallStatusChangeCancel(aTsyReqHandle);
+ case EMobileCallHoldCancel:
+ return HoldCancel(aTsyReqHandle);
+ case EMobileCallGetMobileCallInfoCancel:
+ return GetMobileCallInfoCancel(aTsyReqHandle);
+ case EMobileCallResumeCancel:
+ return ResumeCancel(aTsyReqHandle);
+ case EMobileCallSwapCancel:
+ return SwapCancel(aTsyReqHandle);
+ case EMobileCallNotifyMobileCallCapsChangeCancel:
+ return NotifyMobileCallCapsChangeCancel(aTsyReqHandle);
+ case EMobileCallNotifyCallEventCancel:
+ return NotifyCallEventCancel(aTsyReqHandle);
+ case EMobileCallDialEmergencyCallCancel:
+ return DialEmergencyCallCancel(aTsyReqHandle);
+ case EMobileCallNotifyRemotePartyInfoChangeCancel:
+ return NotifyRemotePartyInfoChangeCancel(aTsyReqHandle);
+ case EMobileCallNotifyVoiceFallbackCancel:
+ return NotifyVoiceFallbackCancel(aTsyReqHandle);
+ case EMobileCallNotifyUUSCapsChangeCancel:
+ return NotifyUUSCapsChangeCancel(aTsyReqHandle);
+ case EMobileCallDialNoFdnCheckCancel:
+ return DialNoFdnCheckCancel(aTsyReqHandle);
+ case EMobileCallDialCallControlCancel:
+ return DialCallControlCancel(aTsyReqHandle);
+ case EMobileCallNotifyAudioToneEventCancel:
+ return NotifyAudioToneEventCancel(aTsyReqHandle);
+ case EMobileCallDialISVCancel:
+ return DialISVCancel(aTsyReqHandle);
+ case EMobileCallAnswerISVCancel:
+ return AnswerIncomingCallISVCancel(aTsyReqHandle);
+ default:
+ return KErrNotSupported;
+ }
+ }
+
+TInt CCallDMmTsy::CancelService(const TInt aIpc, const TTsyReqHandle aTsyReqHandle)
+ {
+ // CancelService is called by the server when it is "cleaning-up" any still outstanding
+ // asynchronous requests before closing a client's sub-session.
+ // This will happen if a client closes its R-class handle without cancelling outstanding
+ // asynchronous requests.
+
+ switch (aIpc)
+ {
+ case EMobileCallNotifyMobileCallStatusChange:
+ return NotifyMobileCallStatusChangeCancel(aTsyReqHandle);
+ case EMobileCallHold:
+ return HoldCancel(aTsyReqHandle);
+ case EMobileCallGetMobileCallInfo:
+ return GetMobileCallInfoCancel(aTsyReqHandle);
+ case EMobileCallResume:
+ return ResumeCancel(aTsyReqHandle);
+ case EMobileCallSwap:
+ return SwapCancel(aTsyReqHandle);
+ case EMobileCallNotifyMobileCallCapsChange:
+ return NotifyMobileCallCapsChangeCancel(aTsyReqHandle);
+ case EMobileCallNotifyCallEvent:
+ return NotifyCallEventCancel(aTsyReqHandle);
+ case EMobileCallDialEmergencyCall:
+ return DialEmergencyCallCancel(aTsyReqHandle);
+ case EMobileCallNotifyRemotePartyInfoChange:
+ return NotifyRemotePartyInfoChangeCancel(aTsyReqHandle);
+ case EMobileCallNotifyMobileDataCallCapsChange:
+ return NotifyMobileDataCallCapsChangeCancel(aTsyReqHandle);
+ case EMobileCallGetMobileDataCallRLPRange:
+ return GetMobileDataCallRLPRangeCancel(aTsyReqHandle);
+ case EMobileCallSetDynamicHscsdParams:
+ return SetDynamicHscsdParamsCancel(aTsyReqHandle);
+ case EMobileCallNotifyHscsdInfoChange:
+ return NotifyHscsdInfoChangeCancel(aTsyReqHandle);
+ case EMobileCallNotifyVoiceFallback:
+ return NotifyVoiceFallbackCancel(aTsyReqHandle);
+ case EMobileCallNotifyAlternatingCallSwitch:
+ return NotifyAlternatingCallSwitchCancel(aTsyReqHandle);
+ case EMobileCallDeflect:
+ return DeflectCancel(aTsyReqHandle);
+ case EMobileCallTransfer:
+ return TransferCancel(aTsyReqHandle);
+ case EMobileCallGoOneToOne:
+ return GoOneToOneCancel(aTsyReqHandle);
+ case EMobileCallSwitchAlternatingCall:
+ return SwitchAlternatingCallCancel(aTsyReqHandle);
+ case EMobileCallActivateCCBS:
+ return ActivateCCBSCancel(aTsyReqHandle);
+ case EMobileCallNotifyPrivacyConfirmation:
+ return NotifyPrivacyConfirmationCancel(aTsyReqHandle);
+ case EMobileCallNotifyTrafficChannelConfirmation:
+ return NotifyTrafficChannelConfirmationCancel(aTsyReqHandle);
+ case EMobileCallNotifyUUSCapsChange:
+ return NotifyUUSCapsChangeCancel(aTsyReqHandle);
+ case EMobileCallActivateUUS:
+ return ActivateUUSCancel(aTsyReqHandle);
+ case EMobileCallSendUUI:
+ return SendUUICancel(aTsyReqHandle);
+ case EMobileCallReceiveUUI:
+ return ReceiveUUICancel(aTsyReqHandle);
+ case EMobileCallHangupWithUUI:
+ return HangupWithUUICancel(aTsyReqHandle);
+ case EMobileCallAnswerWithUUI:
+ return AnswerIncomingCallWithUUICancel(aTsyReqHandle);
+ case EMobileCallDialNoFdnCheck:
+ return DialNoFdnCheckCancel(aTsyReqHandle);
+ case EMobileCallDialCallControl:
+ return DialCallControlCancel(aTsyReqHandle);
+ case EMobileCallAnswerMultimediaCallAsVoice:
+ return AnswerMultimediaCallAsVoiceCancel(aTsyReqHandle);
+ case EMobileCallNotifyAudioToneEvent:
+ return NotifyAudioToneEventCancel(aTsyReqHandle);
+ case EMobileCallDialISV:
+ return DialISVCancel(aTsyReqHandle);
+ case EMobileCallAnswerISV:
+ return AnswerIncomingCallISVCancel(aTsyReqHandle);
+ default:
+ return CCallBase::CancelService(aIpc,aTsyReqHandle);
+ }
+ }
+
+/***********************************************************************************/
+//
+// The following methods are called from ExtFunc and/or CancelService.
+// Each of these will process a TSY request or cancel a TSY request
+// Here, example values are returned or checked within this dummy TSY in order to ensure
+// that the integrity of the data passed to/from client is maintained
+//
+/***********************************************************************************/
+
+
+TInt CCallDMmTsy::GetMobileDataCallCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileDataCallCaps called"));
+ InitialiseDataCallCaps(aCaps);
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileDataCallCapsChange(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+ {
+ if (!iNotifyMobileDataCallCapsChange++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileDataCallCapsChange called"));
+ InitialiseDataCallCaps(aCaps);
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileDataCallCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileDataCallCapsChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+void CCallDMmTsy::InitialiseDataCallCaps(TDes8* aCallCaps)
+ {
+ RMobileCall::TMobileCallDataCapsV1Pckg* callCapsV1Pckg = REINTERPRET_CAST(RMobileCall::TMobileCallDataCapsV1Pckg*,aCallCaps);
+ RMobileCall::TMobileCallDataCapsV1& callCapsV1 = (*callCapsV1Pckg)();
+
+ callCapsV1.iSpeedCaps = DMMTSY_CALL_DATA_CAPS_SPEED;
+ callCapsV1.iProtocolCaps = DMMTSY_CALL_DATA_CAPS_CARRIER;
+ callCapsV1.iServiceCaps = DMMTSY_CALL_DATA_CAPS_SERVICE;
+ callCapsV1.iHscsdSupport = DMMTSY_CALL_DATA_CAPS_HSCSD;
+ callCapsV1.iMClass = DMMTSY_CALL_DATA_CAPS_MCLASS;
+ callCapsV1.iMaxRxTimeSlots = DMMTSY_CALL_DATA_CAPS_MAXRXTS;
+ callCapsV1.iMaxTxTimeSlots = DMMTSY_CALL_DATA_CAPS_MAXTXTS;
+ callCapsV1.iTotalRxTxTimeSlots = DMMTSY_CALL_DATA_CAPS_TOTRXTXTS;
+ callCapsV1.iCodingCaps = DMMTSY_CALL_DATA_CAPS_CODING;
+ callCapsV1.iAsymmetryCaps = DMMTSY_CALL_DATA_CAPS_ASYMETRY;
+ callCapsV1.iUserInitUpgrade = DMMTSY_CALL_DATA_CAPS_USERIMI;
+ }
+
+TInt CCallDMmTsy::GetMobileDataCallRLPRange(const TTsyReqHandle aTsyReqHandle, TInt* aRLPVersion, TDes8* aRLPRange)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileDataCallRLPRange called"));
+
+ RMobileCall::TMobileDataRLPRangesV1Pckg* rlpRangeV1Pckg = REINTERPRET_CAST(RMobileCall::TMobileDataRLPRangesV1Pckg*, aRLPRange);
+ RMobileCall::TMobileDataRLPRangesV1& rlpRangeV1 = (*rlpRangeV1Pckg)();
+
+ if(*aRLPVersion == DMMTSY_CALL_RLP_VERSION1)
+ {
+ rlpRangeV1.iIWSMax = DMMTSY_CALL_DATA_RLP_WSMAX;
+ rlpRangeV1.iIWSMin = DMMTSY_CALL_DATA_RLP_WSMIN;
+ rlpRangeV1.iMWSMax = DMMTSY_CALL_DATA_RLP_MWSMAX;
+ rlpRangeV1.iMWSMin = DMMTSY_CALL_DATA_RLP_MWSMIN;
+ rlpRangeV1.iN2Max = DMMTSY_CALL_DATA_RLP_N2MAX;
+ rlpRangeV1.iN2Min = DMMTSY_CALL_DATA_RLP_N2MIN;
+ rlpRangeV1.iT1Max = DMMTSY_CALL_DATA_RLP_T1MAX;
+ rlpRangeV1.iT1Min = DMMTSY_CALL_DATA_RLP_T1MIN;
+ rlpRangeV1.iT4Max = DMMTSY_CALL_DATA_RLP_T4MAX;
+ rlpRangeV1.iT4Min = DMMTSY_CALL_DATA_RLP_T4MIN;
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetMobileDataCallRLPRangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileDataCallRLPRangeCancel called"));
+
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SetDynamicHscsdParams(const TTsyReqHandle aTsyReqHandle, TInt* aAiur, TInt* aRxTimeslots)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SetHscsdParams called"));
+
+ if ((*aAiur != DMMTSY_CALL_HCSD_AIUR) ||
+ (*aRxTimeslots != DMMTSY_CALL_HCSD_TS))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SetDynamicHscsdParamsCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SetHscsdParamsCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetCurrentHscsdInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aHSCSDInfo)
+ {
+ RMobileCall::TMobileCallHscsdInfoV1Pckg* HSCSDInfoPckg = REINTERPRET_CAST(RMobileCall::TMobileCallHscsdInfoV1Pckg*,aHSCSDInfo);
+ RMobileCall::TMobileCallHscsdInfoV1& hscsdInfo = (*HSCSDInfoPckg)();
+ LOGTEXT(_L8("CCallDMmTsy::GetCurrentHscsdInfo called"));
+ InitialiseHscsdInfo(hscsdInfo);
+
+ if ((hscsdInfo.ExtensionId() == KEtelExtMultimodeV7) ||
+ (hscsdInfo.ExtensionId() == KEtelExtMultimodeV8))
+ {
+ RMobileCall::TMobileCallHscsdInfoV7Pckg* HSCSDInfoV7Pckg = REINTERPRET_CAST(RMobileCall::TMobileCallHscsdInfoV7Pckg*,aHSCSDInfo);
+ RMobileCall::TMobileCallHscsdInfoV7& hscsdInfoV7 = (*HSCSDInfoV7Pckg)();
+
+ hscsdInfoV7.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;
+ hscsdInfoV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;
+ hscsdInfoV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;
+ hscsdInfoV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;
+ hscsdInfoV7.iParamsCallControlModified = DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED;
+ }
+ if (hscsdInfo.ExtensionId() == KEtelExtMultimodeV8)
+ {
+ RMobileCall::TMobileCallHscsdInfoV8Pckg* HSCSDInfoV8Pckg = REINTERPRET_CAST(RMobileCall::TMobileCallHscsdInfoV8Pckg*,aHSCSDInfo);
+ RMobileCall::TMobileCallHscsdInfoV8& hscsdInfoV8 = (*HSCSDInfoV8Pckg)();
+
+ hscsdInfoV8.iSubAddress = DMMTSY_CALL_SUBADDRESS;
+ hscsdInfoV8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;
+ hscsdInfoV8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;
+ hscsdInfoV8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;
+ }
+
+
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyHscsdInfoChange(const TTsyReqHandle aTsyReqHandle, TDes8* aHSCSDInfo)
+ {
+ if (!iNotifyHscsdInfoChange++)
+ {
+ RMobileCall::TMobileCallHscsdInfoV1Pckg* HSCSDInfoPckg = REINTERPRET_CAST(RMobileCall::TMobileCallHscsdInfoV1Pckg*,aHSCSDInfo);
+ RMobileCall::TMobileCallHscsdInfoV1& HSCSDInfo = (*HSCSDInfoPckg)();
+
+ LOGTEXT(_L8("CCallDMmTsy::NotifyHscsdInfoChange called"));
+ InitialiseHscsdInfo(HSCSDInfo);
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyHscsdInfoChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyHscsdInfoChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+void CCallDMmTsy::InitialiseHscsdInfo(RMobileCall::TMobileCallHscsdInfoV1& aHSCSDInfo)
+ {
+ aHSCSDInfo.iAiur = DMMTSY_CALL_HCSD_AIUR;
+ aHSCSDInfo.iRxTimeSlots = DMMTSY_CALL_HCSD_TS;
+ aHSCSDInfo.iTxTimeSlots = DMMTSY_CALL_HCSD_TS;
+ aHSCSDInfo.iCodings = DMMTSY_CALL_HCSD_CODING;
+ }
+
+TInt CCallDMmTsy::NotifyVoiceFallback(const TTsyReqHandle aTsyReqHandle, TDes* aCallName)
+ {
+ if (!iNotifyVoiceFallback++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyVoiceFallback Called"));
+ *aCallName = DMMTSY_VOICE_FALLBACK_CALL_NAME;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyVoiceFallbackCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyVoiceFallbackCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SwitchAlternatingCall(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SwitchAlternatingCall called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SwitchAlternatingCallCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SwitchAlternatingCallCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyAlternatingCallSwitch(const TTsyReqHandle aTsyReqHandle)
+ {
+ if (!iNotifyAlternatingCallSwitch++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyAlternatingCallSwitch called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyAlternatingCallSwitchCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyAlternatingCallSwitchCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+
+
+TInt CCallDMmTsy::GetMobileCallCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileCallCaps called"));
+ RMobileCall::TMobileCallCapsV1Pckg *capsPckg = REINTERPRET_CAST(RMobileCall::TMobileCallCapsV1Pckg *,aCaps);
+ RMobileCall::TMobileCallCapsV1& caps = (*capsPckg)();
+ caps.iCallControlCaps=DMMTSY_CALL_CONTROL_CAPS1;
+ caps.iCallEventCaps=DMMTSY_CALL_EVENT_CAPS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileCallCapsChange(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+ {
+ if(!iNotifyMobileCallCapsChange++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileCallCapsChange called"));
+ RMobileCall::TMobileCallCapsV1Pckg *capsPckg = REINTERPRET_CAST(RMobileCall::TMobileCallCapsV1Pckg *,aCaps);
+ RMobileCall::TMobileCallCapsV1& caps = (*capsPckg)();
+ caps.iCallControlCaps=DMMTSY_CALL_CONTROL_CAPS2;
+ caps.iCallEventCaps=DMMTSY_CALL_EVENT_CAPS2;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileCallCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileCallCapsChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetMobileCallStatus(const TTsyReqHandle aTsyReqHandle,RMobileCall::TMobileCallStatus* aStatus)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileCallStatus called"));
+ *aStatus=DMMTSY_CALL_STATUS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileCallStatusChange(const TTsyReqHandle aTsyReqHandle,RMobileCall::TMobileCallStatus* aStatus)
+ {
+ if (iNotifyMobileCallStatusChange<DMMTSY_NUMBER_OF_SLOTS_STATUS)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileCallStatusChange called"));
+ switch(iNotifyMobileCallStatusChange)
+ {
+ case 0:
+ *aStatus=DMMTSY_CALL_STATUS2;
+ break;
+ case 1:
+ *aStatus=DMMTSY_CALL_STATUS3;
+ break;
+ case 2:
+ *aStatus=DMMTSY_CALL_STATUS4;
+ break;
+ default:
+ break;
+ }
+ iNotifyMobileCallStatusChange++;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyMobileCallStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyMobileCallStatusChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::Hold(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Hold called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::HoldCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::HoldCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::Resume(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Resume called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ResumeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ResumeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::Swap(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Swap called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SwapCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SwapCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::Deflect(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallDeflect* aDeflectType, RMobilePhone::TMobileAddress* aDestination)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Deflect called"));
+
+ if ((*aDeflectType != DMMTSY_CALL_DEFLECT_TYPE) ||
+ (aDestination->iNumberPlan != DMMTSY_PHONE_NPI) ||
+ (aDestination->iTypeOfNumber != DMMTSY_PHONE_TON) ||
+ (aDestination->iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) != 0))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DeflectCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DeflectCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::Transfer(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Transfer called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::TransferCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::TransferCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GoOneToOne(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GoOneToOne called"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GoOneToOneCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GoOneToOneCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyCallEvent(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallEvent* aEvent)
+ {
+ if(!iNotifyCallEvent++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyCallEvent called"));
+ *aEvent=DMMTSY_CALL_EVENT1;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyCallEventCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyCallEventCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SetPrivacySetting(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhonePrivacy* aPrivacySetting)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Set Privacy called"));
+ if (*aPrivacySetting != DMMTSY_CALL_SET_PRIVACY)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyPrivacyConfirmation(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhonePrivacy* aPrivacySetting)
+ {
+ if(!iNotifyPrivacyConfirmation++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Notify Privacy Confirmation Change"));
+ *aPrivacySetting = DMMTSY_CALL_SET_PRIVACY;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyPrivacyConfirmationCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Notify Privacy Confirmation Cancel"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SetTrafficChannel(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallTch* aTchRequest)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Set Traffic Channel called"));
+ if (*aTchRequest != DMMTSY_CALL_TCH_REQUEST)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyTrafficChannelConfirmation(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallTch* aTchType)
+ {
+ if (!iNotifyTrafficChannelConfirmation++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Notify Traffic Channel Confirmation"));
+ *aTchType = DMMTSY_CALL_TCH_SETTING;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyTrafficChannelConfirmationCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::Notify Traffic Channel Confirmation Cancel"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetMobileCallInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aInfo)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileCallInfo called"));
+ RMobileCall::TMobileCallInfoV1Pckg* infoV1Pckg = (RMobileCall::TMobileCallInfoV1Pckg*)aInfo;
+ RMobileCall::TMobileCallInfoV1& infoV1 = (*infoV1Pckg)();
+
+ infoV1.iCallName=DMMTSY_CALL_NAME1;
+ infoV1.iLineName=DMMTSY_LINE_VOICE_NAME;
+ infoV1.iStatus=DMMTSY_CALL_STATUS4;
+ infoV1.iDuration=DMMTSY_CALL_DURATION1;
+ infoV1.iCallId=DMMTSY_CALL_ID1;
+ infoV1.iRemoteParty.iRemoteIdStatus=DMMTSY_CALL_REMOTEPARTYSTATUS1;
+ infoV1.iRemoteParty.iRemoteNumber.iTelNumber=DMMTSY_CALL_REMOTEPARTYNUMBER1;
+ infoV1.iRemoteParty.iDirection=DMMTSY_CALL_REMOTEPARTYDIRECTION1;
+ infoV1.iRemoteParty.iCallingName=DMMTSY_CALL_REMOTEPARTYNAME;
+ infoV1.iExitCode=DMMTSY_CALL_EXIT_CODE;
+ infoV1.iEmergency=DMMTSY_CALL_EMERGENCY_FLAG;
+ infoV1.iForwarded=DMMTSY_CALL_FORWARDED_FLAG;
+ infoV1.iService = DMMTSY_CALL_SERVICE;
+ infoV1.iValid = DMMTSY_CALL_VALID_FLAG;
+ infoV1.iPrivacy = DMMTSY_CALL_PRIVACY;
+ infoV1.iTch = DMMTSY_CALL_CHANNEL;
+ infoV1.iAlternatingCall = DMMTSY_CALL_ALTERNATING;
+ infoV1.iStartTime.Set(DMMTSY_PHONE_NWTINFO_YEAR,DMMTSY_PHONE_NWTINFO_MONTH,DMMTSY_PHONE_NWTINFO_DAY,
+ DMMTSY_PHONE_NWTINFO_HOUR, DMMTSY_PHONE_NWTINFO_MINUTE, DMMTSY_PHONE_NWTINFO_SECOND,
+ DMMTSY_PHONE_NWTINFO_MICRO);
+
+ if (infoV1.ExtensionId() == KETelExtMultimodeV3 ||
+ (infoV1.ExtensionId() == KETelExtMultimodeV4))
+ {
+ RMobileCall::TMobileCallInfoV3Pckg* infoV3Pckg = (RMobileCall::TMobileCallInfoV3Pckg*)aInfo;
+ RMobileCall::TMobileCallInfoV3& infoV3 = (*infoV3Pckg)();
+ infoV3.iSecurity = DMMTSY_CALL_SECURITY;
+ }
+
+ if (infoV1.ExtensionId() == KEtelExtMultimodeV7)
+ {
+ RMobileCall::TMobileCallInfoV7Pckg* infoV7Pckg = (RMobileCall::TMobileCallInfoV7Pckg*)aInfo;
+ RMobileCall::TMobileCallInfoV7& infoV7 = (*infoV7Pckg)();
+ infoV7.iSecurity = DMMTSY_CALL_SECURITY;
+ infoV7.iCallParamOrigin = DMMTSY_CALL_ORIGIN;
+ infoV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;
+ infoV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;
+ infoV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;
+ infoV7.iParamsCallControlModified = DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED;
+ }
+ if (infoV1.ExtensionId() == KEtelExtMultimodeV8)
+ {
+ RMobileCall::TMobileCallInfoV8Pckg* infoV8Pckg = (RMobileCall::TMobileCallInfoV8Pckg*)aInfo;
+ RMobileCall::TMobileCallInfoV8& infoV8 = (*infoV8Pckg)();
+ infoV8.iSecurity = DMMTSY_CALL_SECURITY;
+ infoV8.iCallParamOrigin = DMMTSY_CALL_ORIGIN;
+ infoV8.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;
+ infoV8.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;
+ infoV8.iAlphaId = DMMTSY_CALL_ALPHA_ID;
+ infoV8.iParamsCallControlModified = DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED;
+ infoV8.iSubAddress = DMMTSY_CALL_SUBADDRESS;
+ infoV8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;
+ infoV8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;
+ infoV8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;
+ }
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetMobileCallInfoCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetMobileCallInfoCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyRemotePartyInfoChange(const TTsyReqHandle aTsyReqHandle, TDes8* aRemotePartyInfo)
+ {
+ if (!iNotifyRemotePartyInfoChange++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyRemotePartyInfoChange called"));
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg* infoV1Pckg = (RMobileCall::TMobileCallRemotePartyInfoV1Pckg*)aRemotePartyInfo;
+ RMobileCall::TMobileCallRemotePartyInfoV1& infoV1 = (*infoV1Pckg)();
+
+ infoV1.iRemoteIdStatus=DMMTSY_CALL_REMOTEPARTYSTATUS2;
+ infoV1.iRemoteNumber.iTelNumber=DMMTSY_CALL_EMPTY_STRING;
+ infoV1.iDirection=DMMTSY_CALL_REMOTEPARTYDIRECTION2;
+ infoV1.iCallingName=DMMTSY_CALL_EMPTY_STRING;
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyRemotePartyInfoChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyRemotePartyInfoChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialNoFdnCheck(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDesC* aNumber)
+ /**
+ * This method dials the number specified by aNumber. The number used for dialling
+ * is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+ *
+ * @param aCallParams Supplies the call parameters for the dial request
+ * @param aNumber Supplies the number to dial
+ */
+
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialNoFdnCheck called"));
+
+ TInt error = ValidateCallParams(aCallParams);
+
+ if((error != KErrNone) || (aNumber->Compare(DMMTSY_PHONE_TEL_NUMBER) != 0))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialNoFdnCheck CallParams and DialNumber validated"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialNoFdnCheckCancel(const TTsyReqHandle aTsyReqHandle)
+ /**
+ * This method cancels the dialling of the number specified by aNumber. The number used for dialling
+ * is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+ */
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialNoFdnCheckCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialCallControl(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDesC* aNumber)
+/**
+ * This method dials the number specified by aNumber. Dialling via
+ * this function allows the TSY to know that the dial request is
+ * the result of call control.
+ *
+ * @param aCallParams Supplies the call parameters for the dial request
+ * @param aNumber Supplies the number to dial
+ */
+
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialCallControl called"));
+
+ TInt error = ValidateCallParams(aCallParams); // Check V1 params
+
+ // TODO need to validate the other params
+
+ if((error != KErrNone) || (aNumber->Compare(DMMTSY_PHONE_TEL_NUMBER) != 0))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialCallControl CallParams and DialNumber validated"));
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialCallControlCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * This method cancels the dialling of the number specified by aNumber.
+ */
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialCallControlCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialEmergencyCall(const TTsyReqHandle aTsyReqHandle, TDesC* aNumber)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialEmergencyCall called"));
+ if(aNumber->Compare(DMMTSY_EN_STORE_AMBULANCE_NUM) != 0)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialEmergencyCallCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialEmergencyCallCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::DialISV(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDesC* aNumber)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialISV called"));
+
+ TInt error = KErrNone;
+
+ if(aCallParams)
+ {
+
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg* callparamsPckg=
+ reinterpret_cast<RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg*>(const_cast<TDesC8*>(aCallParams));
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1& callparams=(*callparamsPckg)();
+
+ // check that the request is a 3rd party request
+ if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DIALISV, request from 3rd party."));
+
+ //Validate parameters
+ if ((aNumber->Compare(DMMTSY_PHONE_TEL_NUMBER)!=KErrNone) ||
+ (callparams.iIdRestrict != DMMTSY_CALL_CLI_RESTRICT_SETTING1) ||
+ (callparams.iAutoRedial != DMMTSY_CALL_AUTO_REDIAL_FLAG))
+ {
+ error=KErrCorrupt;
+ }
+ }
+ else
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DIALISV, request from non-3rd party."));
+ error = KErrAccessDenied;
+ }
+ }
+
+ else
+ { // No call parms data
+ error = KErrCorrupt;
+ }
+
+
+ if (error != KErrNone)
+ ReqCompleted(aTsyReqHandle,error);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+
+ }
+
+TInt CCallDMmTsy::DialISVCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::DialISVCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+
+
+TInt CCallDMmTsy::ActivateCCBS(const TTsyReqHandle aTsyReqHandle, TInt* aIndex)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ActivateCCBS called"));
+ *aIndex=DMMTSY_PHONE_CCC_INDEX1;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ActivateCCBSCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ActivateCCBSCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::RejectCCBS(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::RejectCCBS called"));
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::GetUUSCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aCaps)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::GetUUSCaps called"));
+ *aCaps = DMMTSY_CALL_UUS_CAPS;
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyUUSCapsChange(const TTsyReqHandle aTsyReqHandle, TUint32* aCaps)
+ {
+ if (!iNotifyUUSCapsChange++)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyUUSCapsChange called"));
+ *aCaps = DMMTSY_CALL_UUS_CAPS;
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyUUSCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyUUSCapsChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ValidateCallParams(TDesC8* aCallParams)
+ {
+ TInt error = KErrNone;
+
+ RCall::TCallParamsPckg* paramsPckgV1 = (RCall::TCallParamsPckg*)aCallParams;
+ RCall::TCallParams& paramsV1 = (*paramsPckgV1)();
+
+ iDataCallParams.iSpeakerControl = paramsV1.iSpeakerControl;
+ iDataCallParams.iSpeakerVolume = paramsV1.iSpeakerVolume;
+ iDataCallParams.iInterval = paramsV1.iInterval;
+ iDataCallParams.iWaitForDialTone = paramsV1.iWaitForDialTone;
+ iMobileCallParams.iSpeakerControl = paramsV1.iSpeakerControl;
+ iMobileCallParams.iSpeakerVolume = paramsV1.iSpeakerVolume;
+ iMobileCallParams.iInterval = paramsV1.iInterval;
+ iMobileCallParams.iWaitForDialTone = paramsV1.iWaitForDialTone;
+
+ if(paramsV1.ExtensionId()==RMobileCall::KETelMobileCallParamsV1)
+ {
+ if (iMobileCallParams.iInterval != DMMTSY_CALL_INTERVAL)
+ error=KErrCorrupt;
+
+ RMobileCall::TMobileCallParamsV1Pckg* mmParamsPckgV1 = (RMobileCall::TMobileCallParamsV1Pckg*)aCallParams;
+ RMobileCall::TMobileCallParamsV1& mmParamsV1 = (*mmParamsPckgV1)();
+
+ iMobileCallParams.iIdRestrict = mmParamsV1.iIdRestrict;
+ iMobileCallParams.iCug = mmParamsV1.iCug;
+ iMobileCallParams.iAutoRedial = mmParamsV1.iAutoRedial;
+
+ if ((iMobileCallParams.iIdRestrict != DMMTSY_CALL_CLI_RESTRICT_SETTING1) ||
+ (iMobileCallParams.iCug.iExplicitInvoke != DMMTSY_CALL_CUG_INVOKE) ||
+ (iMobileCallParams.iCug.iCugIndex != DMMTSY_CALL_CUG_INDEX) ||
+ (iMobileCallParams.iCug.iSuppressOA != DMMTSY_CALL_CUG_OA) ||
+ (iMobileCallParams.iCug.iSuppressPrefCug != DMMTSY_CALL_CUG_PREF) ||
+ (iMobileCallParams.iAutoRedial != DMMTSY_CALL_AUTO_REDIAL_FLAG))
+
+ error=KErrCorrupt;
+ }
+ else if(paramsV1.ExtensionId()==RMobileCall::KETelMobileCallParamsV2)
+ {
+ if (iMobileCallParams.iInterval != DMMTSY_CALL_INTERVAL)
+ error=KErrCorrupt;
+
+ RMobileCall::TMobileCallParamsV2Pckg* mmParamsPckgV2 = (RMobileCall::TMobileCallParamsV2Pckg*)aCallParams;
+ RMobileCall::TMobileCallParamsV2& mmParamsV2 = (*mmParamsPckgV2)();
+
+ iMobileCallParams.iIdRestrict = mmParamsV2.iIdRestrict;
+ iMobileCallParams.iCug = mmParamsV2.iCug;
+ iMobileCallParams.iAutoRedial = mmParamsV2.iAutoRedial;
+ iMobileCallParams.iBearerMode = mmParamsV2.iBearerMode;
+
+ if ((iMobileCallParams.iIdRestrict != DMMTSY_CALL_CLI_RESTRICT_SETTING1) ||
+ (iMobileCallParams.iCug.iExplicitInvoke != DMMTSY_CALL_CUG_INVOKE) ||
+ (iMobileCallParams.iCug.iCugIndex != DMMTSY_CALL_CUG_INDEX) ||
+ (iMobileCallParams.iCug.iSuppressOA != DMMTSY_CALL_CUG_OA) ||
+ (iMobileCallParams.iCug.iSuppressPrefCug != DMMTSY_CALL_CUG_PREF) ||
+ (iMobileCallParams.iAutoRedial != DMMTSY_CALL_AUTO_REDIAL_FLAG) ||
+ (iMobileCallParams.iBearerMode != DMMTSY_CALL_NEW_BEARER))
+ {
+ error=KErrCorrupt;
+ }
+ }
+ else if (paramsV1.ExtensionId()==RMobileCall::KETelMobileCallParamsV7)
+ {
+ if (iMobileCallParams.iInterval != DMMTSY_CALL_INTERVAL)
+ error=KErrCorrupt;
+
+ RMobileCall::TMobileCallParamsV7Pckg* mmParamsPckgV7 = (RMobileCall::TMobileCallParamsV7Pckg*)aCallParams;
+ RMobileCall::TMobileCallParamsV7& mmParamsV7 = (*mmParamsPckgV7)();
+
+ iMobileCallParams.iIdRestrict = mmParamsV7.iIdRestrict;
+ iMobileCallParams.iCug = mmParamsV7.iCug;
+ iMobileCallParams.iAutoRedial = mmParamsV7.iAutoRedial;
+ iMobileCallParams.iBearerMode = mmParamsV7.iBearerMode;
+ iMobileCallParams.iCallParamOrigin = mmParamsV7.iCallParamOrigin;
+ iMobileCallParams.iSubAddress = mmParamsV7.iSubAddress;
+ iMobileCallParams.iBearerCap1 = mmParamsV7.iBearerCap1;
+ iMobileCallParams.iBearerCap2 = mmParamsV7.iBearerCap2;
+ iMobileCallParams.iBCRepeatIndicator = mmParamsV7.iBCRepeatIndicator;
+ iMobileCallParams.iIconId.iQualifier = mmParamsV7.iIconId.iQualifier;
+ iMobileCallParams.iIconId.iIdentifier = mmParamsV7.iIconId.iIdentifier;
+ iMobileCallParams.iAlphaId = mmParamsV7.iAlphaId;
+
+ if ((iMobileCallParams.iIdRestrict != DMMTSY_CALL_CLI_RESTRICT_SETTING1) ||
+ (iMobileCallParams.iCug.iExplicitInvoke != DMMTSY_CALL_CUG_INVOKE) ||
+ (iMobileCallParams.iCug.iCugIndex != DMMTSY_CALL_CUG_INDEX) ||
+ (iMobileCallParams.iCug.iSuppressOA != DMMTSY_CALL_CUG_OA) ||
+ (iMobileCallParams.iCug.iSuppressPrefCug != DMMTSY_CALL_CUG_PREF) ||
+ (iMobileCallParams.iAutoRedial != DMMTSY_CALL_AUTO_REDIAL_FLAG) ||
+ (iMobileCallParams.iBearerMode != DMMTSY_CALL_NEW_BEARER) ||
+ (iMobileCallParams.iSubAddress != DMMTSY_CALL_SUBADDRESS) ||
+ (iMobileCallParams.iBearerCap1 != DMMTSY_CALL_BEARER_CAP1) ||
+ (iMobileCallParams.iBearerCap2 != DMMTSY_CALL_BEARER_CAP2) ||
+ (iMobileCallParams.iBCRepeatIndicator != DMMTSY_CALL_BC_REPEAT_INDICATOR) ||
+ (iMobileCallParams.iIconId.iQualifier != DMMTSY_CALL_ICON_ID_QUALIFIER) ||
+ (iMobileCallParams.iIconId.iIdentifier != DMMTSY_CALL_ICON_ID_IDENTIFIER) ||
+ (iMobileCallParams.iAlphaId != DMMTSY_CALL_ALPHA_ID))
+ {
+ error=KErrCorrupt;
+ }
+ }
+
+ if ((paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV2) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV8))
+ {
+ RMobileCall::TMobileDataCallParamsV1Pckg* dataParamsPckgV1 = (RMobileCall::TMobileDataCallParamsV1Pckg*)aCallParams;
+ RMobileCall::TMobileDataCallParamsV1& dataParamsV1 = (*dataParamsPckgV1)();
+
+ iDataCallParams.iService = dataParamsV1.iService;
+ iDataCallParams.iSpeed = dataParamsV1.iSpeed;
+ iDataCallParams.iProtocol = dataParamsV1.iProtocol;
+ iDataCallParams.iQoS = dataParamsV1.iQoS;
+ iDataCallParams.iRLPVersion = dataParamsV1.iRLPVersion;
+ iDataCallParams.iV42bisReq = dataParamsV1.iV42bisReq;
+ iDataCallParams.iUseEdge = dataParamsV1.iUseEdge;
+
+ if ((iDataCallParams.iService != DMMTSY_DATA_CALL_SERVICE) ||
+ (iDataCallParams.iSpeed != DMMTSY_DATA_CALL_SPEED) ||
+ (iDataCallParams.iProtocol != DMMTSY_DATA_CALL_PROTOCOL) ||
+ (iDataCallParams.iQoS != DMMTSY_DATA_CALL_QOS) ||
+ (iDataCallParams.iRLPVersion != DMMTSY_DATA_CALL_RLP) ||
+ (iDataCallParams.iV42bisReq != DMMTSY_DATA_CALL_V42BIS) ||
+ (iDataCallParams.iUseEdge != DMMTSY_DATA_CALL_EGPRS_REQUIRED))
+
+ error=KErrCorrupt;
+ }
+
+ if ((paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV2) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV8))
+ {
+ RMobileCall::TMobileDataCallParamsV2Pckg* dataParamsPckgV2 = (RMobileCall::TMobileDataCallParamsV2Pckg*)aCallParams;
+ RMobileCall::TMobileDataCallParamsV2& dataParamsV2 = (*dataParamsPckgV2)();
+
+ iDataCallParams.iBearerMode = dataParamsV2.iBearerMode;
+
+ if (iDataCallParams.iBearerMode != DMMTSY_PHONE_MULTICALLBEARERMODE_NOTSUPPORTED)
+
+ error=KErrCorrupt;
+ }
+ if (paramsV1.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV8)
+ {
+ RMobileCall::TMobileDataCallParamsV8Pckg* dataParamsPckgV8 = (RMobileCall::TMobileDataCallParamsV8Pckg*)aCallParams;
+ RMobileCall::TMobileDataCallParamsV8& dataParamsV8 = (*dataParamsPckgV8)();
+
+ iDataCallParams.iCallParamOrigin = dataParamsV8.iCallParamOrigin;
+ iDataCallParams.iSubAddress = dataParamsV8.iSubAddress;
+ iDataCallParams.iBearerCap1 = dataParamsV8.iBearerCap1;
+ iDataCallParams.iBearerCap2 = dataParamsV8.iBearerCap2;
+ iDataCallParams.iBCRepeatIndicator = dataParamsV8.iBCRepeatIndicator;
+ iDataCallParams.iIconId.iIdentifier = dataParamsV8.iIconId.iIdentifier;
+ iDataCallParams.iIconId.iQualifier = dataParamsV8.iIconId.iQualifier;
+ iDataCallParams.iAlphaId = dataParamsV8.iAlphaId;
+
+ if ((iDataCallParams.iCallParamOrigin != DMMTSY_CALL_PARAM_ORIGIN) ||
+ (iDataCallParams.iSubAddress != DMMTSY_CALL_SUBADDRESS) ||
+ (iDataCallParams.iBearerCap1 != DMMTSY_CALL_BEARER_CAP1) ||
+ (iDataCallParams.iBearerCap2 != DMMTSY_CALL_BEARER_CAP2) ||
+ (iDataCallParams.iBCRepeatIndicator != DMMTSY_CALL_BC_REPEAT_INDICATOR)||
+ (iDataCallParams.iIconId.iIdentifier != DMMTSY_CALL_ICON_ID_IDENTIFIER) ||
+ (iDataCallParams.iIconId.iQualifier != DMMTSY_CALL_ICON_ID_QUALIFIER) ||
+ (iDataCallParams.iAlphaId != DMMTSY_CALL_ALPHA_ID))
+
+ error=KErrCorrupt;
+ }
+
+ if ((paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV2) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV7) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8))
+ {
+ RMobileCall::TMobileHscsdCallParamsV1Pckg* hscsdParamsPckgV1 = (RMobileCall::TMobileHscsdCallParamsV1Pckg*)aCallParams;
+ RMobileCall::TMobileHscsdCallParamsV1& hscsdParamsV1 = (*hscsdParamsPckgV1)();
+
+ iDataCallParams.iWantedAiur = hscsdParamsV1.iWantedAiur;
+ iDataCallParams.iWantedRxTimeSlots = hscsdParamsV1.iWantedRxTimeSlots;
+ iDataCallParams.iMaxTimeSlots = hscsdParamsV1.iMaxTimeSlots;
+ iDataCallParams.iCodings = hscsdParamsV1.iCodings;
+ iDataCallParams.iAsymmetry = hscsdParamsV1.iAsymmetry;
+ iDataCallParams.iUserInitUpgrade = hscsdParamsV1.iUserInitUpgrade;
+
+ if ((iDataCallParams.iWantedAiur != DMMTSY_CALL_HCSD_AIUR) ||
+ (iDataCallParams.iWantedRxTimeSlots != DMMTSY_CALL_HCSD_TS) ||
+ (iDataCallParams.iMaxTimeSlots != DMMTSY_CALL_HCSD_MAXTS) ||
+ (iDataCallParams.iCodings != DMMTSY_CALL_HCSD_CODING) ||
+ (iDataCallParams.iAsymmetry != DMMTSY_CALL_HCSD_ASYMMETRY) ||
+ (iDataCallParams.iUserInitUpgrade != DMMTSY_CALL_HCSD_USER_IMI))
+
+ error=KErrCorrupt;
+ }
+ if ((paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV2) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV7) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8))
+ {
+ RMobileCall::TMobileHscsdCallParamsV2Pckg* hscsdParamsPckgV2 = (RMobileCall::TMobileHscsdCallParamsV2Pckg*)aCallParams;
+ RMobileCall::TMobileHscsdCallParamsV2& hscsdParamsV2 = (*hscsdParamsPckgV2)();
+
+ iDataCallParams.iBearerMode = hscsdParamsV2.iBearerMode;
+
+ if ((iDataCallParams.iBearerMode != DMMTSY_CALL_NEW_BEARER))
+
+ error=KErrCorrupt;
+ }
+
+ if ((paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV7) ||
+ (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8))
+ {
+ RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 = (RMobileCall::TMobileHscsdCallParamsV7Pckg*)aCallParams;
+ RMobileCall::TMobileHscsdCallParamsV7& hscsdParamsV7 = (*hscsdParamsPckgV7)();
+
+ iDataCallParams.iCallParamOrigin = hscsdParamsV7.iCallParamOrigin;
+ iDataCallParams.iIconId = hscsdParamsV7.iIconId;
+ iDataCallParams.iAlphaId = hscsdParamsV7.iAlphaId;
+
+ if ((iDataCallParams.iCallParamOrigin != DMMTSY_CALL_PARAM_ORIGIN) ||
+ (iDataCallParams.iAlphaId != DMMTSY_CALL_ALPHA_ID))
+
+ error=KErrCorrupt;
+ }
+
+ if (paramsV1.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8)
+ {
+ RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 = (RMobileCall::TMobileHscsdCallParamsV8Pckg*)aCallParams;
+ RMobileCall::TMobileHscsdCallParamsV8& hscsdParamsV8 = (*hscsdParamsPckgV8)();
+
+ iDataCallParams.iBearerMode = hscsdParamsV8.iBearerMode;
+ iDataCallParams.iCallParamOrigin = hscsdParamsV8.iCallParamOrigin;
+ iDataCallParams.iIconId.iIdentifier = hscsdParamsV8.iIconId.iIdentifier;
+ iDataCallParams.iIconId.iQualifier = hscsdParamsV8.iIconId.iQualifier;
+ iDataCallParams.iAlphaId = hscsdParamsV8.iAlphaId;
+ iDataCallParams.iSubAddress = hscsdParamsV8.iSubAddress;
+ iDataCallParams.iBearerCap1 = hscsdParamsV8.iBearerCap1;
+ iDataCallParams.iBearerCap2 = hscsdParamsV8.iBearerCap2;
+ iDataCallParams.iBCRepeatIndicator = hscsdParamsV8.iBCRepeatIndicator;
+
+ if ((iDataCallParams.iBearerMode != DMMTSY_CALL_NEW_BEARER) ||
+ (iDataCallParams.iCallParamOrigin != DMMTSY_CALL_PARAM_ORIGIN) ||
+ (iDataCallParams.iIconId.iIdentifier != DMMTSY_CALL_ICON_ID_IDENTIFIER) ||
+ (iDataCallParams.iIconId.iQualifier != DMMTSY_CALL_ICON_ID_QUALIFIER) ||
+ (iDataCallParams.iAlphaId != DMMTSY_CALL_ALPHA_ID)||
+ (iDataCallParams.iSubAddress != DMMTSY_CALL_SUBADDRESS) ||
+ (iDataCallParams.iBearerCap1 != DMMTSY_CALL_BEARER_CAP1) ||
+ (iDataCallParams.iBearerCap2 != DMMTSY_CALL_BEARER_CAP2) ||
+ (iDataCallParams.iBCRepeatIndicator != DMMTSY_CALL_BC_REPEAT_INDICATOR))
+ {
+ error = KErrCorrupt;
+ }
+ }
+
+ return error;
+ }
+
+TInt CCallDMmTsy::ActivateUUS(const TTsyReqHandle aTsyReqHandle, TDes8* aUUIRequest)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ActivateUUS called"));
+
+ RMobileCall::TMobileCallUUSRequestV1Pckg* uuiReqPckg = (RMobileCall::TMobileCallUUSRequestV1Pckg*)aUUIRequest;
+ RMobileCall::TMobileCallUUSRequestV1& uuiReq = (*uuiReqPckg)();
+
+ if((uuiReq.iServiceReq != DMMTSY_CALL_UUI_SERVICE_REQ) ||
+ (uuiReq.iUUI.Compare(DMMTSY_CALL_UUI_INFO_DIAL) !=0 ))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ActivateUUSCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ActivateUUSDuringCallCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SendUUI(const TTsyReqHandle aTsyReqHandle, TBool* aMore, TDesC16* aUUI)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SendUUI called"));
+ if( (aUUI->Compare(DMMTSY_CALL_UUI_INFO) != 0) ||
+ (*aMore != DMMTSY_CALL_UUI_MORE_INFO) )
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::SendUUICancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::SendUUICancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ReceiveUUI(const TTsyReqHandle aTsyReqHandle, TDes16* aUUI)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ReceiveUUI called"));
+
+ aUUI->Copy(DMMTSY_CALL_UUI_INFO);
+
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::ReceiveUUICancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ReceiveUUICancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::HangupWithUUI(const TTsyReqHandle aTsyReqHandle, TDesC16* aUUI)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::HangupWithUUI called"));
+
+ if(aUUI->Compare(DMMTSY_CALL_UUI_INFO_HANGUP) != 0)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle, this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::HangupWithUUICancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::HangupWithUUICancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::AnswerIncomingCallWithUUI(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDesC16* aUUI)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerIncomingCallWithUUI called"));
+
+ TInt error = ValidateCallParams(aCallParams);
+
+ if((error != KErrNone) || (aUUI->Compare(DMMTSY_CALL_UUI_INFO_ANSWER) != 0))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::AnswerIncomingCallWithUUICancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerIncomingCallWithUUICancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+
+TInt CCallDMmTsy::AnswerMultimediaCallAsVoice(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDes16* aCallName)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerMultimediaCallAsVoice called"));
+
+ TInt error = ValidateCallParams(aCallParams);
+
+ *aCallName=DMMTSY_LINE_VOICE_NAME;
+ if(error != KErrNone)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::AnswerMultimediaCallAsVoiceCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerMultimediaCallAsVoiceCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::AnswerIncomingCallISV(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerIncomingCallISV called"));
+
+ TInt error = KErrNone;
+
+ if(aCallParams)
+ {
+
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg* callparamsPckg=
+ reinterpret_cast<RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg*>(const_cast<TDesC8*>(aCallParams));
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1& callparams=(*callparamsPckg)();
+
+ // check that the request is a 3rd party request
+ if(callparams.ExtensionId() == RMobileCall::KETel3rdPartyCallParamsV1)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ANSWERINCOMINGCALLISV, request from 3rd party."));
+ }
+ else
+ {
+ LOGTEXT(_L8("CCallDMmTsy::ANSWERINCOMINGCALLISV, request from non-3rd party."));
+ error = KErrAccessDenied;
+ }
+ }
+
+ else
+ { // No call parms data
+ error = KErrCorrupt;
+ }
+
+
+ if (error != KErrNone)
+ ReqCompleted(aTsyReqHandle,error);
+ else
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+ return KErrNone;
+
+ }
+
+TInt CCallDMmTsy::AnswerIncomingCallISVCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::AnswerIncomingCallISVCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyAudioToneEvent(const TTsyReqHandle aTsyReqHandle, TDes8* aAudioTone)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyAudioToneEventChange called"));
+
+ RMobileCall::TAudioToneV3Pckg* audioPckgV3 = (RMobileCall::TAudioToneV3Pckg*)aAudioTone;
+ RMobileCall::TAudioToneV3& audioTone = (*audioPckgV3)();
+
+ switch(iNotifyAudioToneEvent++)
+ {
+ case 0:
+ audioTone.iEvent = DMMTSY_AUDIO_START_TONE;
+ audioTone.iTone = DMMTSY_AUDIO_CONGESTION_TONE;
+ audioTone.iPlayedLocally = DMMTSY_AUDIO_PLAYED_LOCALLY;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ case 1:
+ audioTone.iEvent = DMMTSY_AUDIO_STOP_TONE;
+ audioTone.iTone = DMMTSY_AUDIO_NO_TONE;
+ audioTone.iPlayedLocally = DMMTSY_AUDIO_PLAYED_LOCALLY;
+ iPhone->AddDelayedReq(aTsyReqHandle,this);
+ break;
+ default:
+ break;
+ }
+ return KErrNone;
+ }
+
+TInt CCallDMmTsy::NotifyAudioToneEventCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CCallDMmTsy::NotifyAudioToneEventChangeCancel called"));
+ iPhone->RemoveDelayedReq(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }