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