--- /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 <ctsy/ltsy/mltsydispatchcallcontrolinterface.h>
+#include <ctsy/pluginapi/mmmessagemanagercallback.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+
+#include <ctsy/ltsy/ltsylogger.h>
+#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<MLtsyDispatchCallControlAnswer*>(answerInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlAnswer, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId))
+ {
+ TAny* holdInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId,
+ holdInterface);
+ iLtsyDispatchCallControlHold =
+ static_cast<MLtsyDispatchCallControlHold*>(holdInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlHold, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId))
+ {
+ TAny* dialEmergencyInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId,
+ dialEmergencyInterface);
+ iLtsyDispatchCallControlDialEmergency =
+ static_cast<MLtsyDispatchCallControlDialEmergency*>(dialEmergencyInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlDialEmergency, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId))
+ {
+ TAny* stopDtmfToneInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId,
+ stopDtmfToneInterface);
+ iLtsyDispatchCallControlStopDtmfTone =
+ static_cast<MLtsyDispatchCallControlStopDtmfTone*>(stopDtmfToneInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlStopDtmfTone, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId))
+ {
+ TAny* setActiveAlsLineInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId,
+ setActiveAlsLineInterface);
+ iLtsyDispatchCallControlSetActiveAlsLine =
+ static_cast<MLtsyDispatchCallControlSetActiveAlsLine*>(setActiveAlsLineInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSetActiveAlsLine, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId))
+ {
+ TAny* sendDtmfTonesCancelInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId,
+ sendDtmfTonesCancelInterface);
+ iLtsyDispatchCallControlSendDtmfTonesCancel =
+ static_cast<MLtsyDispatchCallControlSendDtmfTonesCancel*>(sendDtmfTonesCancelInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSendDtmfTonesCancel, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId))
+ {
+ TAny* hangUpInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId,
+ hangUpInterface);
+ iLtsyDispatchCallControlHangUp =
+ static_cast<MLtsyDispatchCallControlHangUp*>(hangUpInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlHangUp, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId))
+ {
+ TAny* resumeInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId,
+ resumeInterface);
+ iLtsyDispatchCallControlResume =
+ static_cast<MLtsyDispatchCallControlResume*>(resumeInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlResume, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId))
+ {
+ TAny* setDynamicHscsdParamsInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId,
+ setDynamicHscsdParamsInterface);
+ iLtsyDispatchCallControlSetDynamicHscsdParams =
+ static_cast<MLtsyDispatchCallControlSetDynamicHscsdParams*>(setDynamicHscsdParamsInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSetDynamicHscsdParams, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId))
+ {
+ TAny* dialInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId,
+ dialInterface);
+ iLtsyDispatchCallControlDialVoice =
+ static_cast<MLtsyDispatchCallControlDialVoice*>(dialInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlDialVoice, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId))
+ {
+ TAny* transferInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId,
+ transferInterface);
+ iLtsyDispatchCallControlTransfer =
+ static_cast<MLtsyDispatchCallControlTransfer*>(transferInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlTransfer, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId))
+ {
+ TAny* sendDtmfTonesInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId,
+ sendDtmfTonesInterface);
+ iLtsyDispatchCallControlSendDtmfTones =
+ static_cast<MLtsyDispatchCallControlSendDtmfTones*>(sendDtmfTonesInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSendDtmfTones, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId))
+ {
+ TAny* getIdentityServiceStatusInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId,
+ getIdentityServiceStatusInterface);
+ iLtsyDispatchCallControlGetIdentityServiceStatus =
+ static_cast<MLtsyDispatchCallControlGetIdentityServiceStatus*>(getIdentityServiceStatusInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetIdentityServiceStatus, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId))
+ {
+ TAny* swapInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId,
+ swapInterface);
+ iLtsyDispatchCallControlSwap =
+ static_cast<MLtsyDispatchCallControlSwap*>(swapInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSwap, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId))
+ {
+ TAny* loanDataPortInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId,
+ loanDataPortInterface);
+ iLtsyDispatchCallControlLoanDataPort =
+ static_cast<MLtsyDispatchCallControlLoanDataPort*>(loanDataPortInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlLoanDataPort, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId))
+ {
+ TAny* recoverDataPortInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId,
+ recoverDataPortInterface);
+ iLtsyDispatchCallControlRecoverDataPort =
+ static_cast<MLtsyDispatchCallControlRecoverDataPort*>(recoverDataPortInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlRecoverDataPort, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId))
+ {
+ TAny* startDtmfToneInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId,
+ startDtmfToneInterface);
+ iLtsyDispatchCallControlStartDtmfTone =
+ static_cast<MLtsyDispatchCallControlStartDtmfTone*>(startDtmfToneInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlStartDtmfTone, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetActiveAlsLine::KLtsyDispatchCallControlGetActiveAlsLineApiId))
+ {
+ TAny* GetActiveAlsLineInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetActiveAlsLine::KLtsyDispatchCallControlGetActiveAlsLineApiId,
+ GetActiveAlsLineInterface);
+ iLtsyDispatchCallControlGetActiveAlsLine =
+ static_cast<MLtsyDispatchCallControlGetActiveAlsLine*>(GetActiveAlsLineInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetActiveAlsLine, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialData::KLtsyDispatchCallControlDialDataApiId))
+ {
+ TAny* dialDataInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlDialData::KLtsyDispatchCallControlDialDataApiId,
+ dialDataInterface);
+ iLtsyDispatchCallControlDialData =
+ static_cast<MLtsyDispatchCallControlDialData*>(dialDataInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlDialData, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId))
+ {
+ TAny* queryIsEmergencyNumberInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId,
+ queryIsEmergencyNumberInterface);
+ iLtsyDispatchCallControlQueryIsEmergencyNumber =
+ static_cast<MLtsyDispatchCallControlQueryIsEmergencyNumber*>(queryIsEmergencyNumberInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlQueryIsEmergencyNumber, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId))
+ {
+ TAny* getAlsPpSupportInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId,
+ getAlsPpSupportInterface);
+ iLtsyDispatchCallControlGetAlsPpSupport =
+ static_cast<MLtsyDispatchCallControlGetAlsPpSupport*>(getAlsPpSupportInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetAlsPpSupport, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId))
+ {
+ TAny* getAlsBlockedStatusInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId,
+ getAlsBlockedStatusInterface);
+ iLtsyDispatchCallControlGetAlsBlockedStatus =
+ static_cast<MLtsyDispatchCallControlGetAlsBlockedStatus*>(getAlsBlockedStatusInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetAlsBlockedStatus, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId))
+ {
+ TAny* setAlsBlockedInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId,
+ setAlsBlockedInterface);
+ iLtsyDispatchCallControlSetAlsBlocked =
+ static_cast<MLtsyDispatchCallControlSetAlsBlocked*>(setAlsBlockedInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlSetAlsBlocked, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId))
+ {
+ TAny* getLifeTimeInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId,
+ getLifeTimeInterface);
+ iLtsyDispatchCallControlGetLifeTime =
+ static_cast<MLtsyDispatchCallControlGetLifeTime*>(getLifeTimeInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetLifeTime, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId))
+ {
+ TAny* terminateErrorCallInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId,
+ terminateErrorCallInterface);
+ iLtsyDispatchCallControlTerminateErrorCall =
+ static_cast<MLtsyDispatchCallControlTerminateErrorCall*>(terminateErrorCallInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlTerminateErrorCall, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId))
+ {
+ TAny* terminateAllCallsInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId,
+ terminateAllCallsInterface);
+ iLtsyDispatchCallControlTerminateAllCalls =
+ static_cast<MLtsyDispatchCallControlTerminateAllCalls*>(terminateAllCallsInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlTerminateAllCalls, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId))
+ {
+ TAny* getCallForwardingIndicatorInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId,
+ getCallForwardingIndicatorInterface);
+ iLtsyDispatchCallControlGetCallForwardingIndicator =
+ static_cast<MLtsyDispatchCallControlGetCallForwardingIndicator*>(getCallForwardingIndicatorInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlGetCallForwardingIndicator, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId))
+ {
+ TAny* updateLifeTimerInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId,
+ updateLifeTimerInterface);
+ iLtsyDispatchCallControlUpdateLifeTimer =
+ static_cast<MLtsyDispatchCallControlUpdateLifeTimer*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<const CCallDataPackage*>(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<RMobileCall::TMobileCallStatus*>(&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<RMobileCall::TMobileCallDataCapsV1*>(&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<RMobileCall::TMobileCallInfoV1*>(&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<RMobileCall::TMobileCallHscsdInfoV8*>(&aCallParams),
+ const_cast<RMobileCall::TMobileCallDataCapsV1*>(&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<RMobileCall::TMobileCallEvent*>(&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<RMobileCall::TMobileCallInfoV1*>(&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<RMobilePhone::TMobilePhoneIdServiceStatus*>(&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<RMobilePhone::TMobilePhoneALSLine*>(&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<const CCallDataPackage*>(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<RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg*>(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<const CCallDataPackage*>(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<RMmCustomAPI::TCFIndicators*>(&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
+