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

#include <etelsat.h>

#include <ctsy/ltsy/mltsydispatchfactory.h>

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <ctsy/pluginapi/mmmessagemanagercallback.h>

#include <ctsy/serviceapi/mstktsycallorigin.h>

#include <satcs.h>

#include <ctsy/ltsy/ltsylogger.h>

#include "ctsydispatcherpanic.h"

#include "tdispatcherholder.h"

#include <ctsy/ltsy/sat_defs.h>

#include <ctsy/rmmcustomapi.h> //for ECustomSatRefreshCompleteNotificationIPC

__DEBUG_ONLY(const TInt KNmrLength = 16;) //this value is the length of a buffer within commonstktsy - its not defined anywhere as a constant. 

__DEBUG_ONLY(const TInt KBcchListLength = 32;)  //this value is the length of a buffer within commonstktsy - its not defined anywhere as a constant.

//const TUint8 KBasicIconDataLength		= 2;

//const TUint8 KColourIconDataLength		= KIconInfoLength;

CSatDispatcher::CSatDispatcher(

		MLtsyDispatchFactoryV1& aLtsyFactory,

		MmMessageManagerCallback& aTsyMessageManagerCallback,

		MmMessageManagerCallback& aSatMessageManagerCallback,

		CRequestQueueOneShot& aRequestAsyncOneShot)

	: 	iLtsyFactoryV1(aLtsyFactory),

		iTsyMessageManagerCallback(aTsyMessageManagerCallback),

		iMessageManagerCallback(aSatMessageManagerCallback),

		iRequestAsyncOneShot(aRequestAsyncOneShot),

		iLocalInfoOngoing(EFalse)

	{

	} // CSatDispatcher::CSatDispatcher

CSatDispatcher::~CSatDispatcher()

	{

	} // CSatDispatcher::~CSatDispatcher

CSatDispatcher* CSatDispatcher::NewLC(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aTsyMessageManagerCallback,

	MmMessageManagerCallback& aSatMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CSatDispatcher* self =

		new (ELeave) CSatDispatcher(aLtsyFactory, aTsyMessageManagerCallback, aSatMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	} // CSatDispatcher::NewLC

CSatDispatcher* CSatDispatcher::NewL(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aTsyMessageManagerCallback,

	MmMessageManagerCallback& aSatMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CSatDispatcher* self =

		CSatDispatcher::NewLC(aLtsyFactory, aTsyMessageManagerCallback, aSatMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::Pop (self);

	return self;

	} // CSatDispatcher::NewL

void CSatDispatcher::ConstructL()

/**

 * Second phase constructor.

 */

	{

	TSYLOGENTRYEXIT;

	// Get the Licensee LTSY interfaces related to Sat functionality

	// from the factory

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatSmsDeliverReport::KLtsyDispatchSatSmsDeliverReportApiId))

		{

		TAny* smsDeliverReportInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatSmsDeliverReport::KLtsyDispatchSatSmsDeliverReportApiId,

		       	smsDeliverReportInterface);

		iLtsyDispatchSatSmsDeliverReport =

				static_cast<MLtsyDispatchSatSmsDeliverReport*>(smsDeliverReportInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatSmsDeliverReport, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId))

		{

		TAny* getImageInstanceInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId,

		       	getImageInstanceInterface);

		iLtsyDispatchSatGetImageInstance =

				static_cast<MLtsyDispatchSatGetImageInstance*>(getImageInstanceInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetImageInstance, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId))

		{

		TAny* getIconDataInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId,

		       	getIconDataInterface);

		iLtsyDispatchSatGetIconData =

				static_cast<MLtsyDispatchSatGetIconData*>(getIconDataInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetIconData, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId))

		{

		TAny* getClutInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId,

		       	getClutInterface);

		iLtsyDispatchSatGetClut =

				static_cast<MLtsyDispatchSatGetClut*>(getClutInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetClut, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(	KDispatchSatFuncUnitId, 

													MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId))

		{

		TAny* getDefaultBearerCapabilityInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId,

		       	getDefaultBearerCapabilityInterface);

		iLtsyDispatchSatGetDefaultBearerCapability =

				static_cast<MLtsyDispatchSatGetDefaultBearerCapability*>(getDefaultBearerCapabilityInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetDefaultBearerCapability, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(	KDispatchSatFuncUnitId, 

													MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId))

		{

		TAny* smsPpDdlStatusInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId,

		       	smsPpDdlStatusInterface);

		iLtsyDispatchSatGetSmsPpDownloadSupported =

				static_cast<MLtsyDispatchSatGetSmsPpDownloadSupported*>(smsPpDdlStatusInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetSmsPpDownloadSupported, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(	KDispatchSatFuncUnitId, 

													MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId))

		{

		TAny* getSmsControlActivatedInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId,

		       	getSmsControlActivatedInterface);

		iLtsyDispatchSatGetSmsControlActivated =

				static_cast<MLtsyDispatchSatGetSmsControlActivated*>(getSmsControlActivatedInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetSmsControlActivated, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId))

		{

		TAny* accTechInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId,

		       	accTechInterface);

		iLtsyDispatchSatAccTech =

				static_cast<MLtsyDispatchSatGetAccessTechnology*>(accTechInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatAccTech, CtsyDispatcherPanic(EInvalidNullPtr));

   		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatCellBroadcastEnvelope::KLtsyDispatchSatCellBroadcastEnvelopeApiId))

		{

		TAny* cellBroadcastInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatCellBroadcastEnvelope::KLtsyDispatchSatCellBroadcastEnvelopeApiId,

		       	cellBroadcastInterface);

		iLtsyDispatchSatCellBroadcast =

				static_cast<MLtsyDispatchSatCellBroadcastEnvelope*>(cellBroadcastInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatCellBroadcast, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatTimingAdvance::KLtsyDispatchSatTimingAdvanceApiId))

		{

		TAny* timingAdvanceInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatTimingAdvance::KLtsyDispatchSatTimingAdvanceApiId,

		       	timingAdvanceInterface);

		iLtsyDispatchSatTimingAdvance =

				static_cast<MLtsyDispatchSatTimingAdvance*>(timingAdvanceInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatTimingAdvance, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatSmControlResponseData::KLtsyDispatchSatSmControlResponseDataApiId))

		{

		TAny* smControlResponseDataInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatSmControlResponseData::KLtsyDispatchSatSmControlResponseDataApiId,

		       	smControlResponseDataInterface);

		iLtsyDispatchSatSmControlResponseData =

				static_cast<MLtsyDispatchSatSmControlResponseData*>(smControlResponseDataInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatSmControlResponseData, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatProvideLocationInfo::KLtsyDispatchSatProvideLocationInfoApiId))

		{

		TAny* provideLocationInfoInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatProvideLocationInfo::KLtsyDispatchSatProvideLocationInfoApiId,

		       	provideLocationInfoInterface);

		iLtsyDispatchSatProvideLocationInfo =

				static_cast<MLtsyDispatchSatProvideLocationInfo*>(provideLocationInfoInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatProvideLocationInfo, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId))

		{

		TAny* setPollingIntervalInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId,

		       	setPollingIntervalInterface);

		iLtsyDispatchSatSetPollingInterval =

				static_cast<MLtsyDispatchSatSetPollingInterval*>(setPollingIntervalInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatSetPollingInterval, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatSmsPpDownloadEnvelope::KLtsyDispatchSatSmsPpDownloadEnvelopeApiId))

		{

		TAny* smsPpDownloadEnvelopeInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatSmsPpDownloadEnvelope::KLtsyDispatchSatSmsPpDownloadEnvelopeApiId,

		       	smsPpDownloadEnvelopeInterface);

		iLtsyDispatchSatSmsPpDownloadEnvelope =

				static_cast<MLtsyDispatchSatSmsPpDownloadEnvelope*>(smsPpDownloadEnvelopeInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatSmsPpDownloadEnvelope, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatLocalInformationNmr::KLtsyDispatchSatLocalInformationNmrApiId))

		{

		TAny* localInformationNmrInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatLocalInformationNmr::KLtsyDispatchSatLocalInformationNmrApiId,

		       	localInformationNmrInterface);

		iLtsyDispatchSatLocalInformationNmr =

				static_cast<MLtsyDispatchSatLocalInformationNmr*>(localInformationNmrInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatLocalInformationNmr, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(	KDispatchSatFuncUnitId, 

													MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId))

		{

		TAny* callAndSmsControlEnvelopeInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId,

		       	callAndSmsControlEnvelopeInterface);

		iLtsyDispatchSatSendEnvelope =

				static_cast<MLtsyDispatchSatCallAndSmsControlEnvelope*>(callAndSmsControlEnvelopeInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatSendEnvelope, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatRefreshAllowed::KLtsyDispatchSatRefreshAllowedApiId))

		{

		TAny* refreshAllowedInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatRefreshAllowed::KLtsyDispatchSatRefreshAllowedApiId,

		       	refreshAllowedInterface);

		iLtsyDispatchSatRefreshAllowed =

				static_cast<MLtsyDispatchSatRefreshAllowed*>(refreshAllowedInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatRefreshAllowed, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId))

		{

		TAny* readyInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,

		       	readyInterface);

		iLtsyDispatchSatReady =

				static_cast<MLtsyDispatchSatReady*>(readyInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatReady, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId))

		{

		TAny* pCmdNotificationInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,

		       	pCmdNotificationInterface);

		iLtsyDispatchSatPCmdNotification =

				static_cast<MLtsyDispatchSatPCmdNotification*>(pCmdNotificationInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatPCmdNotification, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(	KDispatchSatFuncUnitId, 

													MLtsyDispatchSatUssdControlEnvelopeError::KLtsyDispatchSatUssdControlEnvelopeErrorApiId))

		{

		TAny* envelopeErrorInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatUssdControlEnvelopeError::KLtsyDispatchSatUssdControlEnvelopeErrorApiId,

		       	envelopeErrorInterface);

		iLtsyDispatchSatUssdControlEnvelopeError =

				static_cast<MLtsyDispatchSatUssdControlEnvelopeError*>(envelopeErrorInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatUssdControlEnvelopeError, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatTimerExpirationEnvelope::KLtsyDispatchSatTimerExpirationEnvelopeApiId))

		{

		TAny* timerExpirationEnvelopInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatTimerExpirationEnvelope::KLtsyDispatchSatTimerExpirationEnvelopeApiId,

		       	timerExpirationEnvelopInterface);

		iLtsyDispatchSatTimerExpired =

				static_cast<MLtsyDispatchSatTimerExpirationEnvelope*>(timerExpirationEnvelopInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatTimerExpired, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId))

		{

		TAny* terminalRspInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId,

		       	terminalRspInterface);

		iLtsyDispatchSatTerminalRsp =

				static_cast<MLtsyDispatchSatTerminalRsp*>(terminalRspInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatTerminalRsp, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId))

		{

		TAny* menuSelectionEnvelopeInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId,

		       	menuSelectionEnvelopeInterface);

		iLtsyDispatchSatMenuSelection =

				static_cast<MLtsyDispatchSatMenuSelectionEnvelope*>(menuSelectionEnvelopeInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatMenuSelection, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId))

		{

		TAny* eventDownloadEnvelopeInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,

		       	eventDownloadEnvelopeInterface);

		iLtsyDispatchSatEventDownload =

				static_cast<MLtsyDispatchSatEventDownloadEnvelope*>(eventDownloadEnvelopeInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatEventDownload, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSatFuncUnitId, MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId))

		{

		TAny* GetUssdControlSupportedInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

				MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId,

		       	GetUssdControlSupportedInterface);

		iLtsyDispatchSatGetUssdControlSupported =

				static_cast<MLtsyDispatchSatGetUssdControlSupported*>(GetUssdControlSupportedInterface);

        __ASSERT_DEBUG(iLtsyDispatchSatGetUssdControlSupported, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	} // CSatDispatcher::ConstructL

void CSatDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)

/**

 * Set the dispatcher holder.  

 * 

 * @param aDispatcherHolder Reference to dispatcher holder.

 */

	{

	TSYLOGENTRYEXIT;

	iDispatcherHolder = &aDispatcherHolder;

	} // CSatDispatcher::SetDispatcherHolder

/**

 * Allows the CTSY Dispatcher to ascertain

 * whether a call was requested by a Proactive Command.

 *          

 * @param aSatCallOrigin Interface to the cstktsy

 */

void CSatDispatcher::SetSatCallOriginInterface(MStkTsyCallOrigin& aSatCallOrigin)

	{

	TSYLOGENTRYEXIT;

	iStkTsyCallOrigin = &aSatCallOrigin;

	}

TBool CSatDispatcher::IsSimOriginatedCall(const RMobilePhone::TMobileAddress& aDialledParty)

/**

 * Checks if the dialled party details passed into this function orignally came 

 * from the SIM. e.g. From a SET UP CALL proactive command. 

 * 

 * @param aDialledParty The dialled party details.

 * @return ETrue if the details did originally come from the SIM, EFalse otherwise.

 */

	{

	TSYLOGENTRYEXIT;	

	TInt ret = EFalse;

	 if (iStkTsyCallOrigin)

		{

		//convert 16-bit ascii to 8-bit ascii.

		TBuf8<RMobilePhone::KMaxMobileTelNumberSize> address;

		address.Copy(aDialledParty.iTelNumber);

		ret = iStkTsyCallOrigin->IsSimOriginatedCall(address);

		}

	return ret;

	} // CSatDispatcher::IsSimOriginatedCall

void CSatDispatcher::CompleteNotifyLocalInfo(TInt aError)

	{

	//send off the in progress terminal response now that we have collected the required information for it.

	if (iLocalInfoOngoing)

		{

		TTerminalRespData resp;

		if (KErrNone == aError)

			{

			resp.iGeneralResult = RSat::KSuccess;

			resp.iAdditionalInfo.Zero();

			}

		else

			{

			resp.iGeneralResult = RSat::KMeUnableToProcessCmd;

			resp.iAdditionalInfo.Zero();

			resp.iAdditionalInfo.Append( RSat::KNoSpecificMeProblem );

			}

		CMmDataPackage dataPackage;

		dataPackage.PackData(&resp);

		iMessageManagerCallback.Complete(ESatTsyNotifyLocalInfo, &dataPackage, aError);

		iLocalInfoOngoing = EFalse;

		}

	} //CSatDispatcher::CompleteNotifyLocalInfo

TInt CSatDispatcher::DispatchSmsDeliverReportL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to ESatTsySmsDeliverReport

 * and pass request on to Licensee LTSY.

 *

 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.

 *

 * @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));

    TBuf8<KTpduMaxSize>* reportData = NULL;

	aDataPackage->UnPackData(&reportData);

	__ASSERT_DEBUG(reportData, CtsyDispatcherPanic(EInvalidNullPtr));

	// Call Handle... method in Licensee LTSY

	if (iLtsyDispatchSatSmsDeliverReport)

		{

		ret = iLtsyDispatchSatSmsDeliverReport->HandleSmsDeliverReportReqL(*reportData);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSatDispatcher::DispatchSmsDeliverReportL

TInt CSatDispatcher::DispatchGetImageInstanceL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to ESatTsyGetImageInstance

 * and pass request on to Licensee LTSY.

 *

 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.

 *

 * @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));

	TBuf8<KGetIconDataPckgLength> data;

	aDataPackage->UnPackData(data);

	__ASSERT_DEBUG(data.Length() == KGetIconDataPckgLength, CtsyDispatcherPanic(EBadLength));

	// Call Handle... method in Licensee LTSY

	if (iLtsyDispatchSatGetImageInstance)

		{

		//data[0] Record number

		//data[1] Image instance number in the record

		ret = iLtsyDispatchSatGetImageInstance->HandleGetImageInstanceReqL(data[0],data[1]);

		}

	return TSYLOGSETEXITERR(ret);

	} // CSatDispatcher::DispatchGetImageInstanceL

TInt CSatDispatcher::DispatchGetIconDataL(const CMmDataPackage* aDataPackage)

/**

 * Unpack data related to ESatTsyGetIconData

 * and pass request on to Licensee LTSY.

 *

 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.

 *

 * @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));