// 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

