// 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 "csupplementaryservicesdispatcher.h"

#include <ctsy/ltsy/mltsydispatchsupplementaryservicesinterface.h>

#include <ctsy/pluginapi/mmmessagemanagercallback.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <mmlist.h>

#include <ctsy/rmmcustomapi.h>

#include <ctsy/ltsy/ltsylogger.h>

#include "ctsydispatcherpanic.h"

#include "tdispatcherholder.h"

CSupplementaryServicesDispatcher::CSupplementaryServicesDispatcher(

		MLtsyDispatchFactoryV1& aLtsyFactory,

		MmMessageManagerCallback& aMessageManagerCallback,

		CRequestQueueOneShot& aRequestAsyncOneShot)

	: 	iLtsyFactoryV1(aLtsyFactory),

		iMessageManagerCallback(aMessageManagerCallback),

		iRequestAsyncOneShot(aRequestAsyncOneShot)

	{

	} // CSupplementaryServicesDispatcher::CSupplementaryServicesDispatcher

CSupplementaryServicesDispatcher::~CSupplementaryServicesDispatcher()

	{

	} // CSupplementaryServicesDispatcher::~CSupplementaryServicesDispatcher

CSupplementaryServicesDispatcher* CSupplementaryServicesDispatcher::NewLC(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CSupplementaryServicesDispatcher* self =

		new (ELeave) CSupplementaryServicesDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	} // CSupplementaryServicesDispatcher::NewLC

CSupplementaryServicesDispatcher* CSupplementaryServicesDispatcher::NewL(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CSupplementaryServicesDispatcher* self =

		CSupplementaryServicesDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::Pop (self);

	return self;

	} // CSupplementaryServicesDispatcher::NewL

void CSupplementaryServicesDispatcher::ConstructL()

/**

 * Second phase constructor.

 */

	{

	TSYLOGENTRYEXIT;

	// Get the Licensee LTSY interfaces related to SupplementaryServices functionality

	// from the factory

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId))

		{

		TAny* sendNetworkServiceRequestNoFdnCheckInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId,

		       	sendNetworkServiceRequestNoFdnCheckInterface);

		iLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck =

				static_cast<MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck*>(sendNetworkServiceRequestNoFdnCheckInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesGetCallWaitingStatus::KLtsyDispatchSupplementaryServicesGetCallWaitingStatusApiId))

		{

		TAny* getCallWaitingStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesGetCallWaitingStatus::KLtsyDispatchSupplementaryServicesGetCallWaitingStatusApiId,

		       	getCallWaitingStatusInterface);

		iLtsyDispatchSupplementaryServicesGetCallWaitingStatus =

				static_cast<MLtsyDispatchSupplementaryServicesGetCallWaitingStatus*>(getCallWaitingStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesGetCallWaitingStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestApiId))

		{

		TAny* sendNetworkServiceRequestInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestApiId,

		       	sendNetworkServiceRequestInterface);

		iLtsyDispatchSupplementaryServicesSendNetworkServiceRequest =

				static_cast<MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest*>(sendNetworkServiceRequestInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSendNetworkServiceRequest, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesGetCallBarringStatus::KLtsyDispatchSupplementaryServicesGetCallBarringStatusApiId))

		{

		TAny* getCallBarringStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesGetCallBarringStatus::KLtsyDispatchSupplementaryServicesGetCallBarringStatusApiId,

		       	getCallBarringStatusInterface);

		iLtsyDispatchSupplementaryServicesGetCallBarringStatus =

				static_cast<MLtsyDispatchSupplementaryServicesGetCallBarringStatus*>(getCallBarringStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesGetCallBarringStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSetCallBarringStatus::KLtsyDispatchSupplementaryServicesSetCallBarringStatusApiId))

		{

		TAny* setCallBarringStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSetCallBarringStatus::KLtsyDispatchSupplementaryServicesSetCallBarringStatusApiId,

		       	setCallBarringStatusInterface);

		iLtsyDispatchSupplementaryServicesSetCallBarringStatus =

				static_cast<MLtsyDispatchSupplementaryServicesSetCallBarringStatus*>(setCallBarringStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSetCallBarringStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSetCallForwardingStatus::KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId))

		{

		TAny* setCallForwardingStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSetCallForwardingStatus::KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId,

		       	setCallForwardingStatusInterface);

		iLtsyDispatchSupplementaryServicesSetCallForwardingStatus =

				static_cast<MLtsyDispatchSupplementaryServicesSetCallForwardingStatus*>(setCallForwardingStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSetCallForwardingStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSetCallWaitingStatus::KLtsyDispatchSupplementaryServicesSetCallWaitingStatusApiId))

		{

		TAny* setCallWaitingStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSetCallWaitingStatus::KLtsyDispatchSupplementaryServicesSetCallWaitingStatusApiId,

		       	setCallWaitingStatusInterface);

		iLtsyDispatchSupplementaryServicesSetCallWaitingStatus =

				static_cast<MLtsyDispatchSupplementaryServicesSetCallWaitingStatus*>(setCallWaitingStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSetCallWaitingStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSetSsPassword::KLtsyDispatchSupplementaryServicesSetSsPasswordApiId))

		{

		TAny* setSsPasswordInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSetSsPassword::KLtsyDispatchSupplementaryServicesSetSsPasswordApiId,

		       	setSsPasswordInterface);

		iLtsyDispatchSupplementaryServicesSetSsPassword =

				static_cast<MLtsyDispatchSupplementaryServicesSetSsPassword*>(setSsPasswordInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSetSsPassword, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesGetCallForwardingStatus::KLtsyDispatchSupplementaryServicesGetCallForwardingStatusApiId))

		{

		TAny* getCallForwardingStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesGetCallForwardingStatus::KLtsyDispatchSupplementaryServicesGetCallForwardingStatusApiId,

		       	getCallForwardingStatusInterface);

		iLtsyDispatchSupplementaryServicesGetCallForwardingStatus =

				static_cast<MLtsyDispatchSupplementaryServicesGetCallForwardingStatus*>(getCallForwardingStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesGetCallForwardingStatus, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSendUssdMessage::KLtsyDispatchSupplementaryServicesSendUssdMessageApiId))

		{

		TAny* sendUssdMessageInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSendUssdMessage::KLtsyDispatchSupplementaryServicesSendUssdMessageApiId,

		       	sendUssdMessageInterface);

		iLtsyDispatchSupplementaryServicesSendUssdMessage =

				static_cast<MLtsyDispatchSupplementaryServicesSendUssdMessage*>(sendUssdMessageInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSendUssdMessage, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck::KLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheckApiId))

		{

		TAny* sendUssdMessageNoFdnCheckInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck::KLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheckApiId,

		       	sendUssdMessageNoFdnCheckInterface);

		iLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck =

				static_cast<MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck*>(sendUssdMessageNoFdnCheckInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesSendUssdRelease::KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId))

		{

		TAny* sendUssdReleaseInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesSendUssdRelease::KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId,

		       	sendUssdReleaseInterface);

		iLtsyDispatchSupplementaryServicesSendUssdRelease =

				static_cast<MLtsyDispatchSupplementaryServicesSendUssdRelease*>(sendUssdReleaseInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesSendUssdRelease, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSupplementaryServicesFuncUnitId, MLtsyDispatchSupplementaryServicesClearBlacklist::KLtsyDispatchSupplementaryServicesClearBlacklistApiId))

		{

		TAny* clearBlacklistInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSupplementaryServicesClearBlacklist::KLtsyDispatchSupplementaryServicesClearBlacklistApiId,

		       	clearBlacklistInterface);

		iLtsyDispatchSupplementaryServicesClearBlacklist =

				static_cast<MLtsyDispatchSupplementaryServicesClearBlacklist*>(clearBlacklistInterface);

        __ASSERT_DEBUG(iLtsyDispatchSupplementaryServicesClearBlacklist, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	} // CSupplementaryServicesDispatcher::ConstructL

void CSupplementaryServicesDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)

/**

 * Set the dispatcher holder.  

 * 

 * @param aDispatcherHolder Reference to dispatcher holder.

 */

	{

	TSYLOGENTRYEXIT;

	iDispatcherHolder = &aDispatcherHolder;

	} // CSupplementaryServicesDispatcher::SetDispatcherHolder

TInt CSupplementaryServicesDispatcher::DispatchSendNetworkServiceRequestNoFdnCheckL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSendNetworkServiceRequestNoFdnCheck

 * 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 (iLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck)

		{

		const TDesC* request;

		aDataPackage->UnPackData(request);

		ret = iLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck->HandleSendNetworkServiceRequestNoFdnCheckReqL(*request);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSendNetworkServiceRequestNoFdnCheckL

TInt CSupplementaryServicesDispatcher::DispatchGetCallWaitingStatusL()

/**

 * Pass EMobilePhoneGetWaitingStatusPhase1 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 (iLtsyDispatchSupplementaryServicesGetCallWaitingStatus)

		{

		ret = iLtsyDispatchSupplementaryServicesGetCallWaitingStatus->HandleGetCallWaitingStatusReqL();

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchGetCallWaitingStatusL

TInt CSupplementaryServicesDispatcher::DispatchSendNetworkServiceRequestL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSendNetworkServiceRequest

 * 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 (iLtsyDispatchSupplementaryServicesSendNetworkServiceRequest)

		{

		const TDesC* request;

		aDataPackage->UnPackData(request);

		ret = iLtsyDispatchSupplementaryServicesSendNetworkServiceRequest->HandleSendNetworkServiceRequestReqL(*request);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSendNetworkServiceRequestL

TInt CSupplementaryServicesDispatcher::DispatchGetCallBarringStatusL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneGetBarringStatusPhase1

 * 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 (iLtsyDispatchSupplementaryServicesGetCallBarringStatus)

		{

		RMobilePhone::TMobilePhoneCBCondition condition;

		aDataPackage->UnPackData(condition);

		ret = iLtsyDispatchSupplementaryServicesGetCallBarringStatus->HandleGetCallBarringStatusReqL(condition);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchGetCallBarringStatusL

TInt CSupplementaryServicesDispatcher::DispatchSetCallBarringStatusL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSetCallBarringStatus

 * 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 (iLtsyDispatchSupplementaryServicesSetCallBarringStatus)

		{

		RMobilePhone::TMobilePhoneCBCondition condition;

		RMobilePhone::TMobilePhoneCBChangeV1* info;

		aDataPackage->UnPackData(condition, info);

		ret = iLtsyDispatchSupplementaryServicesSetCallBarringStatus->HandleSetCallBarringStatusReqL(condition,

				info->iAction, info->iServiceGroup, info->iPassword);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSetCallBarringStatusL

TInt CSupplementaryServicesDispatcher::DispatchSetCallForwardingStatusL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSetCallForwardingStatus

 * 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 (iLtsyDispatchSupplementaryServicesSetCallForwardingStatus)

		{

		RMobilePhone::TMobilePhoneCFCondition condition;

		RMobilePhone::TMobilePhoneCFChangeV1* info;

		aDataPackage->UnPackData(condition, info);

		ret = iLtsyDispatchSupplementaryServicesSetCallForwardingStatus->HandleSetCallForwardingStatusReqL(condition,

				info->iServiceGroup,info->iAction,

				info->iNumber.iTelNumber,info->iTimeout);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSetCallForwardingStatusL

TInt CSupplementaryServicesDispatcher::DispatchSetCallWaitingStatusL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSetCallWaitingStatus

 * 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 (iLtsyDispatchSupplementaryServicesSetCallWaitingStatus)

		{

		RMobilePhone::TMobileService service;

		RMobilePhone::TMobilePhoneServiceAction action;

		aDataPackage->UnPackData(service, action);

		ret = iLtsyDispatchSupplementaryServicesSetCallWaitingStatus->HandleSetCallWaitingStatusReqL(service, action);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSetCallWaitingStatusL

TInt CSupplementaryServicesDispatcher::DispatchSetSsPasswordL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneSetSSPassword

 * 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 (iLtsyDispatchSupplementaryServicesSetSsPassword)

		{

		RMobilePhone::TMobilePhonePasswordChangeV2* password = NULL;

		TUint16* services = NULL;

		aDataPackage->UnPackData(&password, &services);

		__ASSERT_DEBUG(password, CtsyDispatcherPanic(EInvalidNullPtr));

		__ASSERT_DEBUG(services, CtsyDispatcherPanic(EInvalidNullPtr));

		//may only come down from the CTSY as hardcoded values of 0 or 330

		//"Password for Barring Services" = 330 

	    //"Common Password for All Appropriate Services" = 0

		__ASSERT_DEBUG(*services == 0 || *services == 330, CtsyDispatcherPanic(EInvalidNullPtr));

		MLtsyDispatchSupplementaryServicesSetSsPassword::TServiceType serviceType 

			= static_cast<MLtsyDispatchSupplementaryServicesSetSsPassword::TServiceType>(*services);

		if(password->iNewPassword != password->iVerifiedPassword)

			{

			ret = KErrArgument;

			}

		else

			{

			ret = iLtsyDispatchSupplementaryServicesSetSsPassword->HandleSetSsPasswordReqL(password->iOldPassword, password->iNewPassword, serviceType);

			}

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSetSsPasswordL

TInt CSupplementaryServicesDispatcher::DispatchGetCallForwardingStatusL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobilePhoneGetCallForwardingStatusPhase1

 * 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 (iLtsyDispatchSupplementaryServicesGetCallForwardingStatus)

		{

		RMobilePhone::TMobilePhoneCFCondition condition;

		RMobilePhone::TMobileService service;

		aDataPackage->UnPackData(condition, service);

		ret = iLtsyDispatchSupplementaryServicesGetCallForwardingStatus->HandleGetCallForwardingStatusReqL(condition, service);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchGetCallForwardingStatusL

TInt CSupplementaryServicesDispatcher::DispatchSendUssdMessageL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobileUssdMessagingSendMessage

 * 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 (iLtsyDispatchSupplementaryServicesSendUssdMessage)

		{

		RMobileUssdMessaging::TMobileUssdAttributesV1Pckg** attributesPckg = NULL;

		RMobileUssdMessaging::TGsmUssdMessageData* data = NULL;

		aDataPackage->UnPackData(&data, &attributesPckg);

		__ASSERT_DEBUG(attributesPckg, CtsyDispatcherPanic(EInvalidNullPtr));

		__ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));

		const RMobileUssdMessaging::TMobileUssdAttributesV1& attributes =(**attributesPckg)();			

		ret = iLtsyDispatchSupplementaryServicesSendUssdMessage->HandleSendUssdMessageReqL(*data,

				attributes.iDcs,

				attributes.iFormat,

				attributes.iType);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSupplementaryServicesDispatcher::DispatchSendUssdMessageL

TInt CSupplementaryServicesDispatcher::DispatchSendUssdMessageNoFdnCheckL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to EMobileUssdMessagingSendMessageNoFdnCheck

 * 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.