diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/src/ccallcontroldispatcher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/src/ccallcontroldispatcher.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2293 @@ +// Copyright (c) 2008-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 "ccallcontroldispatcher.h" + +#include +#include +#include + +#include +#include "ctsydispatcherpanic.h" +#include "tdispatcherholder.h" +#include "csatdispatcher.h" + +CCallControlDispatcher::CCallControlDispatcher( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + : iLtsyFactoryV1(aLtsyFactory), + iMessageManagerCallback(aMessageManagerCallback), + iRequestAsyncOneShot(aRequestAsyncOneShot), + iFoundDtmfStop(EFalse), iModeUsedForVoiceCallDial(RMobilePhone::EServiceUnspecified), + iFdnCheckPerformed(EFalse),iSwapHeldCallId(KInvalidCallId), + iSwapConnectedCallId(KInvalidCallId),iTransferHeldCallId(KInvalidCallId), + iTransferSecondCallId(KInvalidCallId) + { + iDtmfString.Zero(); + } // CCallControlDispatcher::CCallControlDispatcher + + +CCallControlDispatcher::~CCallControlDispatcher() + { + } // CCallControlDispatcher::~CCallControlDispatcher + + +CCallControlDispatcher* CCallControlDispatcher::NewLC( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CCallControlDispatcher* self = + new (ELeave) CCallControlDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } // CCallControlDispatcher::NewLC + + +CCallControlDispatcher* CCallControlDispatcher::NewL( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CCallControlDispatcher* self = + CCallControlDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::Pop (self); + return self; + } // CCallControlDispatcher::NewL + + +void CCallControlDispatcher::ConstructL() +/** + * Second phase constructor. + */ + { + TSYLOGENTRYEXIT; + + // Get the Licensee LTSY interfaces related to CallControl functionality + // from the factory + + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId)) + { + TAny* answerInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, + answerInterface); + iLtsyDispatchCallControlAnswer = + static_cast(answerInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlAnswer, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId)) + { + TAny* holdInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId, + holdInterface); + iLtsyDispatchCallControlHold = + static_cast(holdInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlHold, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId)) + { + TAny* dialEmergencyInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, + dialEmergencyInterface); + iLtsyDispatchCallControlDialEmergency = + static_cast(dialEmergencyInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlDialEmergency, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId)) + { + TAny* stopDtmfToneInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, + stopDtmfToneInterface); + iLtsyDispatchCallControlStopDtmfTone = + static_cast(stopDtmfToneInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlStopDtmfTone, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId)) + { + TAny* setActiveAlsLineInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId, + setActiveAlsLineInterface); + iLtsyDispatchCallControlSetActiveAlsLine = + static_cast(setActiveAlsLineInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSetActiveAlsLine, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId)) + { + TAny* sendDtmfTonesCancelInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId, + sendDtmfTonesCancelInterface); + iLtsyDispatchCallControlSendDtmfTonesCancel = + static_cast(sendDtmfTonesCancelInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSendDtmfTonesCancel, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId)) + { + TAny* hangUpInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, + hangUpInterface); + iLtsyDispatchCallControlHangUp = + static_cast(hangUpInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlHangUp, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId)) + { + TAny* resumeInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, + resumeInterface); + iLtsyDispatchCallControlResume = + static_cast(resumeInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlResume, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId)) + { + TAny* setDynamicHscsdParamsInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, + setDynamicHscsdParamsInterface); + iLtsyDispatchCallControlSetDynamicHscsdParams = + static_cast(setDynamicHscsdParamsInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSetDynamicHscsdParams, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId)) + { + TAny* dialInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId, + dialInterface); + iLtsyDispatchCallControlDialVoice = + static_cast(dialInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlDialVoice, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId)) + { + TAny* transferInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, + transferInterface); + iLtsyDispatchCallControlTransfer = + static_cast(transferInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlTransfer, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId)) + { + TAny* sendDtmfTonesInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, + sendDtmfTonesInterface); + iLtsyDispatchCallControlSendDtmfTones = + static_cast(sendDtmfTonesInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSendDtmfTones, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId)) + { + TAny* getIdentityServiceStatusInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId, + getIdentityServiceStatusInterface); + iLtsyDispatchCallControlGetIdentityServiceStatus = + static_cast(getIdentityServiceStatusInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetIdentityServiceStatus, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId)) + { + TAny* swapInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId, + swapInterface); + iLtsyDispatchCallControlSwap = + static_cast(swapInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSwap, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId)) + { + TAny* loanDataPortInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId, + loanDataPortInterface); + iLtsyDispatchCallControlLoanDataPort = + static_cast(loanDataPortInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlLoanDataPort, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId)) + { + TAny* recoverDataPortInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId, + recoverDataPortInterface); + iLtsyDispatchCallControlRecoverDataPort = + static_cast(recoverDataPortInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlRecoverDataPort, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId)) + { + TAny* startDtmfToneInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, + startDtmfToneInterface); + iLtsyDispatchCallControlStartDtmfTone = + static_cast(startDtmfToneInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlStartDtmfTone, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetActiveAlsLine::KLtsyDispatchCallControlGetActiveAlsLineApiId)) + { + TAny* GetActiveAlsLineInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetActiveAlsLine::KLtsyDispatchCallControlGetActiveAlsLineApiId, + GetActiveAlsLineInterface); + iLtsyDispatchCallControlGetActiveAlsLine = + static_cast(GetActiveAlsLineInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetActiveAlsLine, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialData::KLtsyDispatchCallControlDialDataApiId)) + { + TAny* dialDataInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlDialData::KLtsyDispatchCallControlDialDataApiId, + dialDataInterface); + iLtsyDispatchCallControlDialData = + static_cast(dialDataInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlDialData, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId)) + { + TAny* queryIsEmergencyNumberInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId, + queryIsEmergencyNumberInterface); + iLtsyDispatchCallControlQueryIsEmergencyNumber = + static_cast(queryIsEmergencyNumberInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlQueryIsEmergencyNumber, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId)) + { + TAny* getAlsPpSupportInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId, + getAlsPpSupportInterface); + iLtsyDispatchCallControlGetAlsPpSupport = + static_cast(getAlsPpSupportInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetAlsPpSupport, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId)) + { + TAny* getAlsBlockedStatusInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId, + getAlsBlockedStatusInterface); + iLtsyDispatchCallControlGetAlsBlockedStatus = + static_cast(getAlsBlockedStatusInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetAlsBlockedStatus, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId)) + { + TAny* setAlsBlockedInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId, + setAlsBlockedInterface); + iLtsyDispatchCallControlSetAlsBlocked = + static_cast(setAlsBlockedInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlSetAlsBlocked, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId)) + { + TAny* getLifeTimeInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, + getLifeTimeInterface); + iLtsyDispatchCallControlGetLifeTime = + static_cast(getLifeTimeInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetLifeTime, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId)) + { + TAny* terminateErrorCallInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId, + terminateErrorCallInterface); + iLtsyDispatchCallControlTerminateErrorCall = + static_cast(terminateErrorCallInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlTerminateErrorCall, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId)) + { + TAny* terminateAllCallsInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId, + terminateAllCallsInterface); + iLtsyDispatchCallControlTerminateAllCalls = + static_cast(terminateAllCallsInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlTerminateAllCalls, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId)) + { + TAny* getCallForwardingIndicatorInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId, + getCallForwardingIndicatorInterface); + iLtsyDispatchCallControlGetCallForwardingIndicator = + static_cast(getCallForwardingIndicatorInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlGetCallForwardingIndicator, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId)) + { + TAny* updateLifeTimerInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, + updateLifeTimerInterface); + iLtsyDispatchCallControlUpdateLifeTimer = + static_cast(updateLifeTimerInterface); + __ASSERT_DEBUG(iLtsyDispatchCallControlUpdateLifeTimer, CtsyDispatcherPanic(EInvalidNullPtr)); + } + } // CCallControlDispatcher::ConstructL + + +void CCallControlDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder) +/** + * Set the dispatcher holder. + * + * @param aDispatcherHolder Pointer to dispatcher holder. + */ + { + TSYLOGENTRYEXIT; + + iDispatcherHolder = &aDispatcherHolder; + } // CCallControlDispatcher::SetDispatcherHolder + + +TInt CCallControlDispatcher::DispatchAnswerL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallAnswer + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + + TInt ret = DoDispatchAnswerL(aDataPackage, EFalse); + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchAnswerL + +TInt CCallControlDispatcher::DispatchAnswerIsvL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallAnswerIsv + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + + TInt ret = DoDispatchAnswerL(aDataPackage, ETrue); + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchAnswerIsvL + + +TInt CCallControlDispatcher::DispatchHoldL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallHold + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlHold) + { + const CCallDataPackage* dataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + dataPackage->GetCallIdAndMode(callId, mode); + ret = iLtsyDispatchCallControlHold->HandleHoldReqL(callId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchHoldL + +TInt CCallControlDispatcher::DispatchDialEmergencyL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallDialEmergencyCall + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlDialEmergency) + { + RMobileENStore::TEmergencyNumber* emergencyNumber; + aDataPackage->UnPackData(&emergencyNumber); + + __ASSERT_DEBUG(emergencyNumber, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchCallControlDialEmergency->HandleDialEmergencyReqL(*emergencyNumber); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchDialEmergencyL + +TInt CCallControlDispatcher::DispatchDialNoFdnCheckL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallDialNoFdnCheck + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TInt ret = DoDispatchDialL(aDataPackage, EFalse, EFalse); + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchDialNoFdnCheckL + +TInt CCallControlDispatcher::DispatchStopDtmfToneL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneStopDTMFTone + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlStopDtmfTone) + { + TInt* callId; + aDataPackage->UnPackData(&callId); + ret = iLtsyDispatchCallControlStopDtmfTone->HandleStopDtmfToneReqL(*callId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchStopDtmfToneL + +TInt CCallControlDispatcher::DispatchDialIsvL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallDialISV + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TInt ret = DoDispatchDialL(aDataPackage, ETrue, ETrue); + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchDialIsvL + +TInt CCallControlDispatcher::DispatchSetActiveAlsLineL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneSetALSLine + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlSetActiveAlsLine) + { + RMobilePhone::TMobilePhoneALSLine* alsLine; + aDataPackage->UnPackData(&alsLine); + ret = iLtsyDispatchCallControlSetActiveAlsLine->HandleSetActiveAlsLineReqL(*alsLine); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSetActiveAlsLineL + +TInt CCallControlDispatcher::DispatchSendDtmfTonesCancelL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneSendDTMFTonesCancel + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlSendDtmfTonesCancel) + { + TInt callId; + aDataPackage->UnPackData(callId); + ret = iLtsyDispatchCallControlSendDtmfTonesCancel->HandleSendDtmfTonesCancelReqL(callId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSendDtmfTonesCancelL + +TInt CCallControlDispatcher::DispatchHangUpL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallHangUp + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + if (iLtsyDispatchCallControlHangUp) + { + TInt callId; + RMobilePhone::TMobileService mode; + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + callDataPackage->GetCallIdAndMode(callId, mode); + + TInt hangupCause; + TBool autoStChangeDisable; + callDataPackage->UnPackData(hangupCause, autoStChangeDisable); + + ret = iLtsyDispatchCallControlHangUp->HandleHangUpReqL(callId, hangupCause); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchHangUpL + +TInt CCallControlDispatcher::DispatchResumeL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallResume + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlResume) + { + const CCallDataPackage* dataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + dataPackage->GetCallIdAndMode(callId, mode); + ret = iLtsyDispatchCallControlResume->HandleResumeReqL(callId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchResumeL + +TInt CCallControlDispatcher::DispatchSetDynamicHscsdParamsL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallSetDynamicHscsdParams + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchCallControlSetDynamicHscsdParams) + { + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + callDataPackage->GetCallIdAndMode(callId, mode); + RMobileCall::TMobileHscsdCallParamsV1* hscsdParams; + aDataPackage->UnPackData(&hscsdParams); + ret = iLtsyDispatchCallControlSetDynamicHscsdParams->HandleSetDynamicHscsdParamsReqL(callId, *hscsdParams); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSetDynamicHscsdParamsL + +TInt CCallControlDispatcher::DispatchDialL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallDial + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TInt ret = DoDispatchDialL(aDataPackage, EFalse, ETrue); + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchDialL + +TInt CCallControlDispatcher::DispatchTransferL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallTransfer + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + if (iLtsyDispatchCallControlTransfer) + { + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + RMobilePhone::TMobileService mode; + callDataPackage->GetCallIdAndMode(iTransferHeldCallId, mode); + callDataPackage->UnPackData(iTransferSecondCallId); + ret = iLtsyDispatchCallControlTransfer->HandleTransferReqL(iTransferHeldCallId, iTransferSecondCallId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchTransferL + +TInt CCallControlDispatcher::DispatchSendDtmfTonesL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneSendDTMFTones + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + if (iLtsyDispatchCallControlSendDtmfTones) + { + TInt* callId; + TDesC* tones; + aDataPackage->UnPackData(&callId, &tones); + + ret = DoSendDtmfTonesL(*callId, *tones); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSendDtmfTonesL + +TInt CCallControlDispatcher::DoSendDtmfTonesL(TInt aCallId, const TDesC& aTones) + { + TSYLOGENTRYEXIT; + + TInt ret = KErrNotSupported; + + // Locate a 'w' (wait) in the DTMF string + // Send the part of the string before the 'w' to LTSY, + // cache the rest. + TChar w('w'); + TInt wPos = aTones.LocateF(w); + if (wPos == KErrNotFound) + { + if (iLtsyDispatchCallControlSendDtmfTones) + { + ret = iLtsyDispatchCallControlSendDtmfTones->HandleSendDtmfTonesReqL(aCallId, aTones); + } + } + else + { + iFoundDtmfStop = ETrue; + iCallIdForDtmf = aCallId; + + // Send string before 'w' to LTSY + TPtrC firstPartOfString = aTones.Left(wPos); + if (iLtsyDispatchCallControlSendDtmfTones) + { + ret = iLtsyDispatchCallControlSendDtmfTones->HandleSendDtmfTonesReqL(aCallId, firstPartOfString); + } + + // Cache string after the 'w' so that client can choose to continue sending + // or not. + + // Buffer needs to be big enough to fit the rest of the string after the first 'w' + // (not including the 'w' itself). + iDtmfString = aTones.Right(aTones.Length() - wPos - 1); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DoSendDtmfTonesL + + +TInt CCallControlDispatcher::DispatchGetIdentityServiceStatusL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneGetIdentityServiceStatus + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetIdentityServiceStatus) + { + RMobilePhone::TMobilePhoneIdService idService; + aDataPackage->UnPackData(idService); + ret = iLtsyDispatchCallControlGetIdentityServiceStatus->HandleGetIdentityServiceStatusReqL(idService); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetIdentityServiceStatusL + +TInt CCallControlDispatcher::DispatchSwapL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileCallSwap + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchCallControlSwap) + { + const CCallDataPackage* dataPackage = static_cast(aDataPackage); + RMobilePhone::TMobileService mode; + dataPackage->GetCallIdAndMode(iSwapHeldCallId, mode); + dataPackage->UnPackData(iSwapConnectedCallId); + ret = iLtsyDispatchCallControlSwap->HandleSwapReqL(iSwapHeldCallId, iSwapConnectedCallId); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSwapL + +TInt CCallControlDispatcher::DispatchContinueDtmfStringSendingL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneContinueDTMFStringSending + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TDesC* stringToSend; + aDataPackage->UnPackData(&stringToSend); + if (stringToSend) + { + __ASSERT_DEBUG(stringToSend, CtsyDispatcherPanic(EInvalidNullPtr)); + ret = DoSendDtmfTonesL(iCallIdForDtmf, *stringToSend); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchContinueDtmfStringSendingL + +TInt CCallControlDispatcher::DispatchLoanDataPortL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallLoanDataPort + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + if (iLtsyDispatchCallControlLoanDataPort) + { + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + callDataPackage->GetCallIdAndMode(callId, mode); + RCall::TCommPort* commPort; + callDataPackage->UnPackData(&commPort); + ret = iLtsyDispatchCallControlLoanDataPort->HandleLoanDataPortSyncL(callId, *commPort); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchLoanDataPortL + +TInt CCallControlDispatcher::DispatchRecoverDataPortL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EEtelCallRecoverDataPort + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + if (iLtsyDispatchCallControlRecoverDataPort) + { + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + callDataPackage->GetCallIdAndMode(callId, mode); + RCall::TCommPort* commPort; + callDataPackage->UnPackData(&commPort); + ret = iLtsyDispatchCallControlRecoverDataPort->HandleRecoverDataPortSyncL(callId, *commPort); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchRecoverDataPortL + +TInt CCallControlDispatcher::DispatchStartDtmfToneL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobilePhoneStartDTMFTone + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlStartDtmfTone) + { + TChar* tone; + TInt* callId; + aDataPackage->UnPackData(&callId, &tone); + + ret = iLtsyDispatchCallControlStartDtmfTone->HandleStartDtmfToneReqL(*callId, *tone); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchStartDtmfToneL + + +TInt CCallControlDispatcher::DispatchGetActiveAlsLineL() +/** + * Unpack data related to RMobilePhone::GetActiveAlsLine + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetActiveAlsLine) + { + ret = iLtsyDispatchCallControlGetActiveAlsLine->HandleGetActiveAlsLineReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetActiveAlsLineL + +TInt CCallControlDispatcher::DispatchQueryIsEmergencyNumberL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to ECustomCheckEmergencyNumberIPC + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlQueryIsEmergencyNumber) + { + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + RMmCustomAPI::TEmerNumberCheckMode* numberCheckMode; + aDataPackage->UnPackData(&numberCheckMode); + + TBool isEmergencyNumber = ETrue; + + ret = iLtsyDispatchCallControlQueryIsEmergencyNumber->HandleQueryIsEmergencyNumberSyncL( + numberCheckMode->iNumber, isEmergencyNumber); + + // Trigger async one shot completer + if (ret == KErrNone) + { + // CTSY handling of ECustomCheckEmergencyNumberIPC is as follows... + // It expects the lower layer to do the following: + // + // - If the number is an emergency number, return KErrNone as error code, + // and CMmDataPackage containing the number. + // + // - If the number is not an emergency number, return KErrNone as error code, + // and NULL in the CMmDataPackage. + // + // - If there was a problem checking the number, return error != KErrNone. + + if (isEmergencyNumber) + { + iQueryEmergencyNumber = numberCheckMode->iNumber; + } + else + { + iQueryEmergencyNumber.Zero(); + } + + // For this particular IPC, the CMmDataPackage expected by CTSY on + // callback contains the emergency number sent down originally rather + // than anything explicitly returned by the LTSY in the sync call, + // therefore the number is cached and the CMmDataPackage package is + // constructed on callback. + // dataPackage->iDataPackage is NULL here. + CRequestQueueOneShot::TIpcDataPackage* dataPackage = + new (ELeave) CRequestQueueOneShot::TIpcDataPackage; + dataPackage->iIpc = ECustomCheckEmergencyNumberIPC; + dataPackage->iResultCode = KErrNone; + dataPackage->iDataPackage = NULL; + dataPackage->iDispatcherCallback = this; + iRequestAsyncOneShot.QueueRequest(*dataPackage); + } + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchQueryIsEmergencyNumberL + +TInt CCallControlDispatcher::DispatchGetAlsPpSupportL() +/** + * Pass ECustomCheckAlsPpSupportIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetAlsPpSupport) + { + ret = iLtsyDispatchCallControlGetAlsPpSupport->HandleGetAlsPpSupportL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetAlsPpSupportL + +TInt CCallControlDispatcher::DispatchGetAlsBlockedStatusL() +/** + * Pass ECustomGetAlsBlockedIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetAlsBlockedStatus) + { + ret = iLtsyDispatchCallControlGetAlsBlockedStatus->HandleGetAlsBlockedStatusL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetAlsBlockedStatusL + +TInt CCallControlDispatcher::DispatchSetAlsBlockedL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to ECustomSetAlsBlockedIPC + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlSetAlsBlocked) + { + RMmCustomAPI::TSetAlsBlock alsBlock; + aDataPackage->UnPackData(alsBlock); + ret = iLtsyDispatchCallControlSetAlsBlocked->HandleSetAlsBlockedL(alsBlock); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchSetAlsBlockedL + +TInt CCallControlDispatcher::DispatchGetLifeTimeL() +/** + * Pass ECustomGetLifeTimeIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetLifeTime) + { + ret = iLtsyDispatchCallControlGetLifeTime->HandleGetLifeTimeL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetLifeTimeL + +TInt CCallControlDispatcher::DispatchTerminateCallL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to ECustomTerminateCallIPC + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlTerminateErrorCall && iLtsyDispatchCallControlTerminateAllCalls) + { + TInt callId; + TBool isError; + aDataPackage->UnPackData(callId,isError); + if ((isError) && (callId <= 0)) + { + ret = KErrCorrupt; + } + else if ((!isError) && (callId > 0)) + { + ret = KErrCorrupt; + } + else if(isError) + { + ret = iLtsyDispatchCallControlTerminateErrorCall->HandleTerminateErrorCallL(callId); + } + else + { + // The callId is the negative id of a call in a connecting state (if there is one) + // we shall not pass it to the LTSY since our assumption is that it will know all calls (whether active or in the process of connecting). + ret = iLtsyDispatchCallControlTerminateAllCalls->HandleTerminateAllCallsL(); + } + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchTerminateCallL + +TInt CCallControlDispatcher::DispatchGetCallForwardingIndicatorL() +/** + * Pass ECustomGetIccCallForwardingStatusIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlGetCallForwardingIndicator) + { + ret = iLtsyDispatchCallControlGetCallForwardingIndicator->HandleGetCallForwardingIndicatorL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchGetCallForwardingIndicatorL + +TInt CCallControlDispatcher::DispatchUpdateLifeTimeL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to ECtsyUpdateLifeTimeReq / ECtsyUpdateLifeTimeComp IPCs + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCallControlUpdateLifeTimer) + { + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TUint32 duration; + aDataPackage->UnPackData(duration); + + ret = iLtsyDispatchCallControlUpdateLifeTimer->HandleUpdateLifeTimerReqL(duration); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DispatchUpdateLifeTimeL + +// +// Callback handlers follow +// + + +void CCallControlDispatcher::CallbackNotifyCallStatusChange(TInt aError, + TInt aCallId, RMobileCall::TMobileCallStatus aMobileCallStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd() + * + * Packs data into a format expected by the Common TSY. + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * + * @param aCallId The Call ID of the call aMobileCallStatus refers to. + * + * @param aMobileCallStatus The new status of the call refered to by aCallId. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d, aMobileCallStatus=%d"), aError, aCallId, aMobileCallStatus); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + dataPackage.PackData(const_cast(&aMobileCallStatus)); + + iMessageManagerCallback.Complete(EMobileCallNotifyMobileCallStatusChange, &dataPackage, aError); + + // For data calls, CTSY does not complete dial request back to client + if (aMobileCallStatus == RMobileCall::EStatusConnected) + { + if (iFdnCheckPerformed) + { + iMessageManagerCallback.Complete(EEtelCallDial, &dataPackage, aError); + } + else + { + iMessageManagerCallback.Complete(EMobileCallDialNoFdnCheck, &dataPackage, aError); + } + } + + } // CCallControlDispatcher::CallbackNotifyCallStatusChange + +void CCallControlDispatcher::CallbackReceiveUui( + TInt aError, TInt aCallId, const TDesC& aCallUui) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlReceiveUuiInd(). + * + * @param aError The error code to be returned to the CTSY. + * @param aCallId The Call ID of the call. + * @param aCallUui The UUI information received from the LTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + TPtrC callUui(aCallUui); + + // Pack the data to return to the Common TSY + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + dataPackage.PackData(&callUui); + + iMessageManagerCallback.Complete(EMobileCallReceiveUUI, &dataPackage, aError); + } // CCallControlDispatcher::CallbackReceiveUui + +void CCallControlDispatcher::CallbackNotifyDataCallCapsChange(TInt aError, + TInt aCallId, const RMobileCall::TMobileCallDataCapsV1& aMobileCallDataCaps) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyDataCallCapsChangeInd() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID of the call whose capabilities have changed. + * @param aMobileCallDataCaps The new capabilities of the data call. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + // Pack the data to return to the Common TSY + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + dataPackage.PackData(const_cast(&aMobileCallDataCaps)); + + iMessageManagerCallback.Complete(EMobileCallNotifyMobileDataCallCapsChange, &dataPackage, aError); + } // CCallControlDispatcher::CallbackNotifyDataCallCapsChange + +void CCallControlDispatcher::CallbackNotifyIncomingCall(TInt aError, + const RMobileCall::TMobileCallInfoV1& aCallInfo) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyIncomingCallInd() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallInfo Call information from LTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Pack the data to return to the Common TSY + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallInfo.iCallId, aCallInfo.iService); + dataPackage.PackData(const_cast(&aCallInfo)); + + iMessageManagerCallback.Complete(EEtelLineNotifyIncomingCall, &dataPackage, aError); + + CallbackNotifyCallStatusChange(aError, aCallInfo.iCallId, RMobileCall::EStatusRinging); + + } // CCallControlDispatcher::CallbackNotifyIncomingCall + + +void CCallControlDispatcher::CallbackNotifyHscsdInfoChange(TInt aError, + TInt aCallId, const RMobileCall::TMobileCallHscsdInfoV8& aCallParams, + const RMobileCall::TMobileCallDataCapsV1& aCallCaps) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd(). + * + * @param aError The error code returned from the LTSY. + * @param aCallId The Call ID returned from the LTSY. + * @param aCallParams The call params returned from the LTSY. + * @param aCallInfo The call information returned from the LTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + // Pack the data to return to the Common TSY + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::ECircuitDataService); + dataPackage.PackData(const_cast(&aCallParams), + const_cast(&aCallCaps)); + + iMessageManagerCallback.Complete(EMobileCallNotifyHscsdInfoChange, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackNotifyHscsdInfoChange + +void CCallControlDispatcher::CallbackNotifyCallEvent(TInt aError, + TInt aCallId, RMobileCall::TMobileCallEvent aCallEvent) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyCallEventInd() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId Call ID returned from LTSY + * @param aCallEvent Call event returned from LTSY + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d, aCallEvent=%d"), aError, aCallId, aCallEvent); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + dataPackage.PackData(const_cast(&aCallEvent)); + + iMessageManagerCallback.Complete(EMobileCallNotifyCallEvent, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackNotifyCallEvent + +void CCallControlDispatcher::CallbackNotifyCallInfoChange( + TInt aError, const RMobileCall::TMobileCallInfoV1& aMobileCallInfo) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyCallInfoChangeInd(). + * + * @param aError The error code returned by the LTSY. + * @param aMobileCallInfo The call information relating to the call identified by aCallId. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, callId=%d, callMode=%d"), aError, aMobileCallInfo.iCallId, aMobileCallInfo.iService); + + // Pack the data to return to the Common TSY + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aMobileCallInfo.iCallId, aMobileCallInfo.iService); + dataPackage.PackData(const_cast(&aMobileCallInfo)); + + iMessageManagerCallback.Complete(EMobileCallGetMobileCallInfo, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackNotifyCallInfoChange + +void CCallControlDispatcher::CallbackRemoteAlertingToneChange( + TInt aError, RMmCustomAPI::TRemoteAlertingToneStatus aRemoteAlertingTone) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlRemoteAlertingToneChangeInd(). + * + * @param aError The error code returned by the LTSY. + * @param aRemoteAlertingTone The new remote alerting status (either RMmCustomAPI::EUiRbtTone + * when it is a ringback tone or RMmCustomAPI::EUiStopTone when it's a stop tone) + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aRemoteAlertingTone=%d"), aError, aRemoteAlertingTone); + + CMmDataPackage dataPackage; + + // Pack the data to return to the Common TSY + if(aRemoteAlertingTone != RMmCustomAPI::EUiNoTone) + { + TBool playRemoteAlertToneLocally = (aRemoteAlertingTone == RMmCustomAPI::EUiRbtTone) ? TRUE : FALSE; + dataPackage.PackData(&playRemoteAlertToneLocally); + + iMessageManagerCallback.Complete(ECustomGetRemoteAlertingToneStatusIPC, &dataPackage, aError); + } + + dataPackage.PackData(&aRemoteAlertingTone); + iMessageManagerCallback.Complete(ECustomNotifyRemoteAlertingToneStatusChangeIPC, &dataPackage, aError); + + + } // CCallControlDispatcher::CallbackRemoteAlertingToneChange + + +void CCallControlDispatcher::CallbackAnswer(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlAnswerComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID returned from the LTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + // For cases where the answer completes with no error, call status change + // notifications come from the LTSY to indicate the call is connected. + // The EStatusConnected status will complete the client's answer request. + if (aError != KErrNone) + { + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + iMessageManagerCallback.Complete(EEtelCallAnswer, &dataPackage, aError); + } + + } // CCallControlDispatcher::CallbackAnswer + + +void CCallControlDispatcher::CallbackHold(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlHoldComp(). + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID of the call which was requested to be held. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + + if (aError != KErrNone) + { + iMessageManagerCallback.Complete(EMobileCallHold, &dataPackage, aError); + } + + } // CCallControlDispatcher::CallbackHold + +void CCallControlDispatcher::CallbackDialEmergency(TInt aError, + TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The call ID returned from the LTSY + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + if (aError == KErrNone) + { + DoCallbackDial(aError, aCallId, RMobilePhone::EVoiceService); + iModeUsedForVoiceCallDial = RMobilePhone::EServiceUnspecified; + } + else + { + // When dialling of an emergency call fails, the CTSY expects a particular + // series of completions + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iService = RMobilePhone::EVoiceService; + callInfo.iCallId = aCallId; + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, callInfo.iService); + dataPackage.PackData(&callInfo); + + CallbackNotifyCallInfoChange(aError, callInfo); + + CallbackNotifyCallStatusChange(aError, aCallId, RMobileCall::EStatusIdle); + } + + } // CCallControlDispatcher::CallbackDialEmergency + + +void CCallControlDispatcher::CallbackStopDtmfTone(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobilePhoneStopDTMFTone, aError); + + } // CCallControlDispatcher::CallbackStopDtmfTone + +void CCallControlDispatcher::CallbackSetActiveAlsLine(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobilePhoneSetALSLine, aError); + + } // CCallControlDispatcher::CallbackSetActiveAlsLine + +void CCallControlDispatcher::CallbackSendDtmfTonesCancel(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp(). + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobilePhoneSendDTMFTonesCancel, aError); + } // CCallControlDispatcher::CallbackSendDtmfTonesCancel + +void CCallControlDispatcher::CallbackHangUp(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlHangUpComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID of the call which has been hung up. + * + * @see RCall::HangUp + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + + iMessageManagerCallback.Complete(EEtelCallHangUp, &dataPackage, aError); + } // CCallControlDispatcher::CallbackHangUp + +void CCallControlDispatcher::CallbackResume(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlResumeComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID returned by CCtsyDispatcherCallback. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + + if (aError != KErrNone) + { + iMessageManagerCallback.Complete(EMobileCallResume, &dataPackage, aError); + } + + } // CCallControlDispatcher::CallbackResume + +void CCallControlDispatcher::CallbackSetDynamicHscsdParams(TInt aError, + TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallId The Call ID returned to the CTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + CCallDataPackage dataPackage; + dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified); + + iMessageManagerCallback.Complete(EMobileCallSetDynamicHscsdParams, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackSetDynamicHscsdParams + + +void CCallControlDispatcher::CallbackDialVoice(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp() + * + * @param aError The error code to be returned to the CTSY. + * + * @param aCallId The Call ID returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + DoCallbackDial(aError, aCallId, iModeUsedForVoiceCallDial); + iModeUsedForVoiceCallDial = RMobilePhone::EServiceUnspecified; + + } // CCallControlDispatcher::CallbackDialVoice + +void CCallControlDispatcher::CallbackTransfer(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlTransferComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // If the transfer was not called on this call ID, the CTSY will have + // no reqHandle for this IPC so calling both here is OK. + + // Check in case LTSY has completed a transfer when no transfer was called + // Don't complete back to CTSY in this case + CCallDataPackage dataPackage; + + if (iTransferHeldCallId != KInvalidCallId) + { + dataPackage.SetCallIdAndMode(iTransferHeldCallId, RMobilePhone::EServiceUnspecified); + iTransferHeldCallId = KInvalidCallId; + iMessageManagerCallback.Complete(EMobileCallTransfer, &dataPackage, aError); + } + + if (iTransferSecondCallId != KInvalidCallId) + { + dataPackage.SetCallIdAndMode(iTransferSecondCallId, RMobilePhone::EServiceUnspecified); + iSwapConnectedCallId = KInvalidCallId; + iMessageManagerCallback.Complete(EMobileCallTransfer, &dataPackage, aError); + } + + } // CCallControlDispatcher::CallbackTransfer + +void CCallControlDispatcher::CallbackSendDtmfTones(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + if (iFoundDtmfStop) + { + // Part of the DTMF string (after the 'w') has been cached, and there is + // still more to send so notify the client of the stop character + // Make a copy of the cached data as CTSY deletes previous pointer + CMmDataPackage dataPackage; + dataPackage.PackData(&iDtmfString); + iMessageManagerCallback.Complete(EMobilePhoneNotifyStopInDTMFString, &dataPackage, aError); + iDtmfString.Zero(); + iFoundDtmfStop = EFalse; + } + else + { + // There was no 'w' in the string, normal completion of send + iMessageManagerCallback.Complete(EMobilePhoneSendDTMFTones, aError); + } + + } // CCallControlDispatcher::CallbackSendDtmfTones + +void CCallControlDispatcher::CallbackGetIdentityServiceStatus(TInt aError, + RMobilePhone::TMobilePhoneIdServiceStatus aIdentityServiceStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aIdentityServiceStatus The identity service status returned to the CTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aIdentityServiceStatus=%d"), aError, aIdentityServiceStatus); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast(&aIdentityServiceStatus)); + + iMessageManagerCallback.Complete(EMobilePhoneGetIdentityServiceStatus, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetIdentityServiceStatus + +void CCallControlDispatcher::CallbackSwap(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSwapComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + if (aError != KErrNone) + { + CCallDataPackage dataPackage; + + // If the swap was not called on this call ID, the CTSY will have + // no reqHandle for this IPC so calling both here is OK. + + // Check in case LTSY has completed a swap when no swap was called + // Don't complete back to CTSY in this case + + if (iSwapHeldCallId != KInvalidCallId) + { + dataPackage.SetCallIdAndMode(iSwapHeldCallId, RMobilePhone::EServiceUnspecified); + iSwapHeldCallId = KInvalidCallId; + iMessageManagerCallback.Complete(EMobileCallSwap, &dataPackage, aError); + } + + if (iSwapConnectedCallId != KInvalidCallId) + { + dataPackage.SetCallIdAndMode(iSwapConnectedCallId, RMobilePhone::EServiceUnspecified); + iSwapConnectedCallId = KInvalidCallId; + iMessageManagerCallback.Complete(EMobileCallSwap, &dataPackage, aError); + } + + } + + } // CCallControlDispatcher::CallbackSwap + +void CCallControlDispatcher::CallbackStartDtmfTone(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlStartDtmfToneComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobilePhoneStartDTMFTone, aError); + + } // CCallControlDispatcher::CallbackStartDtmfTone + +void CCallControlDispatcher::CallbackGetActiveAlsLine( + TInt aError, RMobilePhone::TMobilePhoneALSLine aAlsLine) +/** + * Packages the data returned by the Licensee LTSY and completes the + * request back to the Common TSY. + * + * @param aError The error code to complete back. + * @param aAlsLine The ALS line returned by the Licensee LTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d aAlsLine=%d"), aError, aAlsLine); + + // Package up data to return to Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast(&aAlsLine)); + + // Now complete the actual get request + iMessageManagerCallback.Complete(EMobilePhoneGetALSLine, &dataPackage, aError); + + } // CPhoneDispatcher::CallbackGetActiveAlsLine + +void CCallControlDispatcher::CallbackDialData(TInt aError, TInt aCallId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlDialDataComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aCallId The Call ID returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId); + + DoCallbackDial(aError, aCallId, RMobilePhone::ECircuitDataService); + iModeUsedForVoiceCallDial = RMobilePhone::EServiceUnspecified; + + } // CCallControlDispatcher::CallbackDialData + +void CCallControlDispatcher::CallbackGetAlsPpSupport(TInt aError, RMmCustomAPI::TAlsSupport aAlsSupport) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aAlsSupport The return value from the LTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aAlsSupport=%d"), aError, aAlsSupport); + + // Package up data to return to Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aAlsSupport); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomCheckAlsPpSupportIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetAlsPpSupport + +void CCallControlDispatcher::CallbackGetAlsBlockedStatus(TInt aError, RMmCustomAPI::TGetAlsBlockStatus aAlsStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aAlsStatus The return value from the LTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aAlsStatus=%d"), aError, aAlsStatus); + + // Package up data to return to Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aAlsStatus); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetAlsBlockedIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetAlsBlockedStatus + +void CCallControlDispatcher::CallbackSetAlsBlocked(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp(). + * + * @param aError The error code to be returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomSetAlsBlockedIPC, aError); + + } // CCallControlDispatcher::CallbackSetAlsBlocked + +void CCallControlDispatcher::CallbackGetLifeTime(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp(). + * + * @param aError The error code to be returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Package up data to return to Common TSY + RMmCustomAPI::TLifeTimeData data; + data.iCaps = 0; + CMmDataPackage dataPackage; + dataPackage.PackData(&data); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetLifeTimeIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetLifeTime + +void CCallControlDispatcher::CallbackGetLifeTime(TInt aError, TUint32 aHours, TUint8 aMinutes) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aHours The amount of hours of airtime use since the manufacturing date. The range of the value should be 0-999999. + * @param aMinutes The amount of minutes in addition to the amount of hours represented by aHours. The range of the value is 0-59. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aHours=%d, aMinutes=%d"), aError, aHours, aMinutes); + + // Package up data to return to Common TSY + RMmCustomAPI::TLifeTimeData data; + data.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsLifeTime; + data.iHours = aHours; + data.iMinutes = aMinutes; + CMmDataPackage dataPackage; + dataPackage.PackData(&data); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetLifeTimeIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetLifeTime + +void CCallControlDispatcher::CallbackGetLifeTime(TInt aError, const TDateTime &aManufacturingDate) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aManufacturingDate The date of phone manufacturing. Only the Year, Month and day information is meaningful. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Package up data to return to Common TSY + RMmCustomAPI::TLifeTimeData data; + data.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsManufacturerDate; + data.iManufacturingDate = aManufacturingDate; + CMmDataPackage dataPackage; + dataPackage.PackData(&data); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetLifeTimeIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetLifeTime + +void CCallControlDispatcher::CallbackGetLifeTime(TInt aError, const TDateTime &aManufacturingDate, TUint32 aHours, TUint8 aMinutes) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aManufacturingDate The date of phone manufacturing. Only the Year, Month and day information is meaningful. + * @param aHours The amount of hours of airtime use since the manufacturing date. The range of the value should be 0-999999. + * @param aMinutes The amount of minutes in addition to the amount of hours represented by aHours. The range of the value is 0-59. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aHours=%d, aMinutes=%d"), aError, aHours, aMinutes); + + // Package up data to return to Common TSY + RMmCustomAPI::TLifeTimeData data; + data.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsLifeTime | RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsManufacturerDate; + data.iHours = aHours; + data.iMinutes = aMinutes; + data.iManufacturingDate = aManufacturingDate; + CMmDataPackage dataPackage; + dataPackage.PackData(&data); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetLifeTimeIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetLifeTime + +void CCallControlDispatcher::CallbackTerminateErrorCall(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp(). + * + * @param aError The error code to be returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomTerminateCallIPC, aError); + + } // CCallControlDispatcher::CallbackTerminateErrorCall + +void CCallControlDispatcher::CallbackTerminateAllCalls(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlTerminateAllCallsComp(). + * + * @param aError The error code to be returned to the CTSY. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomTerminateCallIPC, aError); + + } // CCallControlDispatcher::CallbackTerminateAllCalls + +void CCallControlDispatcher::CallbackGetCallForwardingIndicator(TInt aError, RMobilePhone::TMobileTON aTypeOfNumber, + RMobilePhone::TMobileNPI aMobilePlan, + const TDesC &aNumber, + RMobilePhone::TCFUIndicatorStatusFlags aCFUIndicatorStatusFlags, + RMobilePhone::TMultipleSubscriberProfileID aMultipleSubscriberProfileId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp(). + * + * @param aError The error code to be returned to the CTSY. + * + * @param aTypeOfNumber The call forwarding type of number. + * @param aMobilePlan The call forwarding mobile plan. + * @param aNumber The call forwarding telephone number. + * @param aCFUIndicatorStatusFlags The setting for indicator status. Can contain a number of flags from RMobilePhone::TCFUIndicatorStatus. + * @param aMultipleSubscriberProfileID The multiple subscriber profile ID. + * + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, Flags=%d, ProfileId=%d"), aError, aCFUIndicatorStatusFlags, aMultipleSubscriberProfileId); + + // Package up data to return to Common TSY + RMmCustomAPI::TCFIndicators data; + data.iCFNumber.iTypeOfNumber = aTypeOfNumber; + data.iCFNumber.iNumberPlan = aMobilePlan; + data.iCFNumber.iTelNumber = aNumber; + data.iIndicator = aCFUIndicatorStatusFlags; + switch(aMultipleSubscriberProfileId) + { + case RMobilePhone::KProfileIdentityUnknown: + break; + case RMobilePhone::KProfileIdentityOne: + data.iMultipleSubscriberProfileID = RMmCustomAPI::KProfileIdentityOne; + break; + case RMobilePhone::KProfileIdentityTwo: + data.iMultipleSubscriberProfileID = RMmCustomAPI::KProfileIdentityTwo; + break; + case RMobilePhone::KProfileIdentityThree: + data.iMultipleSubscriberProfileID = RMmCustomAPI::KProfileIdentityThree; + break; + case RMobilePhone::KProfileIdentityFour: + data.iMultipleSubscriberProfileID = RMmCustomAPI::KProfileIdentityFour; + break; + + } + CMmDataPackage dataPackage; + dataPackage.PackData(&data); + + // Now complete the actual get request + iMessageManagerCallback.Complete(ECustomGetIccCallForwardingStatusIPC, &dataPackage, aError); + + } // CCallControlDispatcher::CallbackGetCallForwardingIndicator + + +void CCallControlDispatcher::CallbackQueryIsEmergencyNumber( + CRequestQueueOneShot::TIpcDataPackage* aDataPackage) +/** + * Callback function to be used by the request to complete + * MLtsyDispatchCallControlQueryIsEmergencyNumber::HandleQueryIsEmergencyNumberSyncL. + * + * @param aDataPackage Structure encapulsating data about the request. + */ + { + TSYLOGENTRYEXITARGS(_L8("iResultCode=%d"), aDataPackage->iResultCode); + + if (!aDataPackage->iCleanupOnly) + { + RMmCustomAPI::TMobileTelNumber* numberPtr = NULL; + if (iQueryEmergencyNumber.Length() > 0) + { + numberPtr = &iQueryEmergencyNumber; + } + + CMmDataPackage mmDataPackage; + mmDataPackage.PackData(&numberPtr); + + iMessageManagerCallback.Complete(ECustomCheckEmergencyNumberIPC, &mmDataPackage, aDataPackage->iResultCode); + + iQueryEmergencyNumber.Zero(); + } + + delete aDataPackage; + } // CCallControlDispatcher::CallbackQueryIsEmergencyNumber + +void CCallControlDispatcher::CallbackUpdateLifeTimer(TInt aError) +/** + * Callback function to be used by the request to complete + * MLtsyDispatchCallControlUpdateLifeTimer::HandleUpdateLifeTimerReqL. + * + * @param aError The error code to be returned to the CTSY + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(ECtsyUpdateLifeTimeComp, aError); + + } // CCallControlDispatcher::CallbackUpdateLifeTimer + +TInt CCallControlDispatcher::DoDispatchDialL(const CMmDataPackage* aDataPackage, + TBool aIsIsvCall, TBool aPerformFdnCheck) + { + TSYLOGENTRYEXITARGS(_L8("aIsIsvCall=%d,aPerformFdnCheck=%d"), aIsIsvCall, aPerformFdnCheck); + + TInt ret = KErrNotSupported; + + iFdnCheckPerformed = aPerformFdnCheck; + + TInt callId; + RMobilePhone::TMobileService mode; + const CCallDataPackage* callDataPackage = static_cast(aDataPackage); + callDataPackage->GetCallIdAndMode(callId, mode); + + iModeUsedForVoiceCallDial = mode; + + RMobileCall::TMobileCallInfoV1* callInfo; + RMobileCall::TMobileCallParamsV1Pckg* callParamsPckg; + aDataPackage->UnPackData(&callParamsPckg, &callInfo); + + __ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr)); + + RMobileCall::TCallParamOrigin callOrigin; + + CSatDispatcher& satDispatcher = iDispatcherHolder->GetSatDispatcher(); + if (satDispatcher.IsSimOriginatedCall(callInfo->iDialledParty)) + { + callOrigin = RMobileCall::EOriginatorSIM; + } + else + { + callOrigin = RMobileCall::EOriginatorEtelClient; + } + + // Call Handle... method in Licensee LTSY + if (mode == RMobilePhone::EVoiceService && + iLtsyDispatchCallControlDialVoice) + { + if (!aIsIsvCall) + { + ret = iLtsyDispatchCallControlDialVoice->HandleDialVoiceReqL( + RMobilePhone::EAlternateLinePrimary, callInfo->iDialledParty, + ((*callParamsPckg)()), aIsIsvCall, callOrigin, aPerformFdnCheck); + } + else + { + aDataPackage->UnPackData(&callParamsPckg, &callInfo); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg* callParams3rdPartyPckg = + reinterpret_cast(callParamsPckg); + RMobileCall::TEtel3rdPartyMobileCallParamsV1* callParams3rdParty = &((*callParams3rdPartyPckg)()); + + RMobileCall::TMobileCallParamsV1 newCallParamsV1; + RMobileCall::TMobileCallParamsV1Pckg newCallParamsV1Pckg(newCallParamsV1); + + // Pack params from 3rd party to V1 + newCallParamsV1.iAutoRedial = callParams3rdParty->iAutoRedial; + newCallParamsV1.iIdRestrict = callParams3rdParty->iIdRestrict; + + ret = iLtsyDispatchCallControlDialVoice->HandleDialVoiceReqL( + RMobilePhone::EAlternateLinePrimary, callInfo->iDialledParty, + newCallParamsV1, aIsIsvCall, callOrigin, aPerformFdnCheck); + + } + } + else if (mode == RMobilePhone::EAuxVoiceService && + iLtsyDispatchCallControlDialVoice) + { + ret = iLtsyDispatchCallControlDialVoice->HandleDialVoiceReqL( + RMobilePhone::EAlternateLineAuxiliary, callInfo->iDialledParty, + ((*callParamsPckg)()), aIsIsvCall, callOrigin, aPerformFdnCheck); + + } + else if (mode == RMobilePhone::ECircuitDataService && + iLtsyDispatchCallControlDialData) + { + RMobileCall::TMobileCallInfoV1* callInfo; + RMobileCall::TMobileDataCallParamsV1Pckg* callParamsPckg; + aDataPackage->UnPackData(&callParamsPckg, &callInfo); + + ret = iLtsyDispatchCallControlDialData->HandleDialDataReqL( + callInfo->iDialledParty, ((*callParamsPckg)()), aPerformFdnCheck); + } + else + { + CtsyDispatcherPanic(EInvalidParameter); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DoDispatchDialL + +TInt CCallControlDispatcher::DoDispatchAnswerL( + const CMmDataPackage* aDataPackage, TBool aIsIsvRequest) + { + TSYLOGENTRYEXIT; + + TInt ret = KErrNotSupported; + + if (iLtsyDispatchCallControlAnswer) + { + const CCallDataPackage* dataPackage = static_cast(aDataPackage); + TInt callId; + RMobilePhone::TMobileService mode; + dataPackage->GetCallIdAndMode(callId, mode); + + ret = iLtsyDispatchCallControlAnswer->HandleAnswerReqL(callId, aIsIsvRequest); + } + + return TSYLOGSETEXITERR(ret); + } // CCallControlDispatcher::DoDispatchAnswerL + +void CCallControlDispatcher::DoCallbackDial(TInt aError, TInt aCallId, + RMobilePhone::TMobileService aMode) + { + TSYLOGENTRYEXIT; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iService = aMode; + CCallDataPackage dataPackage; + + if (aError == KErrNone) + { + // CTSY expects completion of EMobileCallGetMobileCallInfo when a + // dial is requested to get the call ID in the CTSY call object to be set + // correctly. + dataPackage.SetCallIdAndMode(aCallId, callInfo.iService); + dataPackage.PackData(&callInfo); + iMessageManagerCallback.Complete(EMobileCallGetMobileCallInfo, &dataPackage, aError); + } + else + { + dataPackage.SetCallIdAndMode(0, callInfo.iService); + dataPackage.PackData(&callInfo); + + // CTSY only expects EEtelCallDial IPC on a failure to dial + if (iFdnCheckPerformed) + { + iMessageManagerCallback.Complete(EEtelCallDial, &dataPackage, aError); + } + else + { + iMessageManagerCallback.Complete(EMobileCallDialNoFdnCheck, &dataPackage, aError); + } + } + + } // CCallControlDispatcher::DoCallbackDial + +void CCallControlDispatcher::CallbackNotifyIccCallForwardingStatusChange(TInt aError, + const RMobilePhone::TMobileAddress& aCallForwardingNo, + RMobilePhone::TCFUIndicatorStatusFlags aCallForwardingStatusFlags, + RMmCustomAPI::TMultipleSubscriberProfileID aMultipleSubscriberProfileId + ) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCallControlNotifyIccCallForwardingStatusChangeInd(). + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCallForwardingNo the number that is being forwarded. + * @param aCallForwardingStatusFlags flags defined in RMobilePhone::TCFUIndicatorStatus. + * @param aMultipleSubscriberProfileId the Profile ID, in the case of Multiple Subscribers (SIM). + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + // Pack the data to return to the Common TSY + RMmCustomAPI::TCFIndicators callForwardingIndicator; + callForwardingIndicator.iCFNumber = aCallForwardingNo; + callForwardingIndicator.iIndicator = aCallForwardingStatusFlags; + callForwardingIndicator.iMultipleSubscriberProfileID = aMultipleSubscriberProfileId; + + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast(&callForwardingIndicator)); + + iMessageManagerCallback.Complete(ECustomNotifyIccCallForwardingStatusChangeIPC, &dataPackage, aError); + + } // CSimDispatcher::CallbackNotifyIccCallForwardingStatusChange + +void CCallControlDispatcher::CallbackSync(CRequestQueueOneShot::TIpcDataPackage& aIpcDataPackage) +/** + * Part of the MDispatcherCallback interface. Used to complete requests handled + * synchronously by the Licensee LTSY asynchronously back to the Common TSY. + * + * @param aIpcDataPackage Package encapsulating the request. + * + * @see MDispatcherCallback::CallbackSync() + */ + { + TSYLOGENTRYEXIT; + + switch (aIpcDataPackage.iIpc) + { + case ECustomCheckEmergencyNumberIPC: + CallbackQueryIsEmergencyNumber(&aIpcDataPackage); + break; + default: + LOG(_L8("WARNING: CCallControlDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc); + __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc)); + break; + } // switch (aIpcDataPackage.iIpc) + + } // CCallControlDispatcher::CallbackSync +