// 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));
	
	TIconInfo* iconInfo = NULL;
	aDataPackage->UnPackData(&iconInfo);
	
	__ASSERT_DEBUG(iconInfo, CtsyDispatcherPanic(EInvalidNullPtr));

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatGetIconData)
		{
		const TInt KBitsToShiftForDivisonBy256 = 8;
		// iconInfo.iOffset >> 8 undoes the conversion from the record number
		// to an offset done in the CTSY.
		ret = iLtsyDispatchSatGetIconData->HandleGetIconDataReqL(iconInfo->iOffset >> KBitsToShiftForDivisonBy256,iconInfo->iSimFilePath);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchGetIconDataL

TInt CSatDispatcher::DispatchGetClutL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsyGetClut
 * 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 (iLtsyDispatchSatGetClut)
		{
		//data[0] Record number
		//data[1] Instance number in the record
		ret = iLtsyDispatchSatGetClut->HandleGetClutReqL(data[0], data[1]);
		}
	
	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchGetClutL

TInt CSatDispatcher::DispatchGetDefaultBearerCapabilityL()
/**
 * Unpack data related to ESatTsyGetBearerCapability
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatGetDefaultBearerCapability)
		{
		ret = iLtsyDispatchSatGetDefaultBearerCapability->HandleGetDefaultBearerCapabilityReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchGetDefaultBearerCapabilityL

TInt CSatDispatcher::DispatchSmsPpDdlStatusL()
/**
 * Unpack data related to ESatTsySmsPpDdlStatus
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatGetSmsPpDownloadSupported)
		{
		ret = iLtsyDispatchSatGetSmsPpDownloadSupported->HandleGetSmsPpDownloadSupportedReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchSmsPpDdlStatusL

TInt CSatDispatcher::DispatchGetSmsControlActivatedL()
/**
 * Unpack data related to ESatTsyMoSmsControlActivation
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatGetSmsControlActivated)
		{
		ret = iLtsyDispatchSatGetSmsControlActivated->HandleGetSmsControlActivatedReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchGetSmsControlActivatedL

TInt CSatDispatcher::DispatchCellBroadcastL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsyCellBroadcast
 * 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));
	
	TPtrC8* cellBroadcastEnvelope = NULL;
	
	aDataPackage->UnPackData(&cellBroadcastEnvelope);
	
	__ASSERT_DEBUG(cellBroadcastEnvelope, CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatCellBroadcast)
		{
		ret = iLtsyDispatchSatCellBroadcast->HandleCellBroadcastEnvelopeReqL(*cellBroadcastEnvelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchCellBroadcastL

TInt CSatDispatcher::DispatchAccessTechnologyL()
/**
 * Unpack data related to ESatTsyAccTech
 * 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;

	//record that an Local Information proactive command request is in progress
	iLocalInfoOngoing = ETrue;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatAccTech)
		{
		ret = iLtsyDispatchSatAccTech->HandleGetAccessTechnologyReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchAccessTechnologyL


TInt CSatDispatcher::DispatchTimingAdvanceL()
/**
 * Unpack data related to ESatTsyTimingAdvance
 * 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;

	//record that a Local Information proactive command request is in progress
	iLocalInfoOngoing = ETrue;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatTimingAdvance)
		{
		ret = iLtsyDispatchSatTimingAdvance->HandleTimingAdvanceReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchTimingAdvanceL

TInt CSatDispatcher::DispatchNotifySmControlRequestL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatNotifyMoSmControlRequest
 * 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));
	TMoSmCtrlData* moSmsControlData = NULL;
	aDataPackage->UnPackData(&moSmsControlData);
	
	__ASSERT_DEBUG(moSmsControlData, CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatSmControlResponseData)
		{
		ret = iLtsyDispatchSatSmControlResponseData->HandleSmControlResponseDataReqL(	
				moSmsControlData->iResult,
				moSmsControlData->iAddressData.iRPDestinationAddr,
				moSmsControlData->iAddressData.iTPDestinationAddr);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchNotifySmControlRequestL

TInt CSatDispatcher::DispatchProvideLocationInfoL()
/**
 * Pass ESatTsyProvideLocalInfo 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;
	
	//record that a Local Information proactive command request is in progress
	iLocalInfoOngoing = ETrue;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatProvideLocationInfo)
		{
		ret = iLtsyDispatchSatProvideLocationInfo->HandleProvideLocationInfoReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchProvideLocationInfoL

TInt CSatDispatcher::DispatchSetPollingIntervalL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsySetPolling
 * 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<1> data;
	aDataPackage->UnPackData(data);

	__ASSERT_DEBUG(data.Length() == data.MaxLength(), CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatSetPollingInterval)
		{
		ret = iLtsyDispatchSatSetPollingInterval->HandleSetPollingIntervalReqL(data[0]);
		}
	
	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchSetPollingIntervalL

TInt CSatDispatcher::DispatchSmsPpDdlL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsySmsPpDdl
 * 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));
	TPtrC8* smsPpDownloadEnvelope = NULL;
	
	aDataPackage->UnPackData(&smsPpDownloadEnvelope);
	
	__ASSERT_DEBUG(smsPpDownloadEnvelope, CtsyDispatcherPanic(EInvalidNullPtr));

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatSmsPpDownloadEnvelope)
		{
		ret = iLtsyDispatchSatSmsPpDownloadEnvelope->HandleSmsPpDownloadEnvelopeReqL(*smsPpDownloadEnvelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchSmsPpDdlL

TInt CSatDispatcher::DispatchLocalInformationNmrL()
/**
 * Unpack data related to ESatTsyLocalInformationNmr
 * 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;

	//record that a Local Information proactive command request is in progress
	iLocalInfoOngoing = ETrue;
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatLocalInformationNmr)
		{
		ret = iLtsyDispatchSatLocalInformationNmr->HandleLocalInformationNmrReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchLocalInformationNmrL

TInt CSatDispatcher::DispatchSendEnvelopeL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsySendEnvelope
 * 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));
	TPtrC8* envelope = NULL;
	
	aDataPackage->UnPackData(&envelope);
	
	__ASSERT_DEBUG(envelope, CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatSendEnvelope)
		{
		ret = iLtsyDispatchSatSendEnvelope->HandleCallAndSmsControlEnvelopeReqL(*envelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchSendEnvelopeL

TInt CSatDispatcher::DispatchServiceRequestL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsyServiceRequest
 * 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));
	TTerminalRespData* terminalRespData = NULL;
	TRefreshInfo* refreshInfo = NULL;
	
	aDataPackage->UnPackData(&terminalRespData,&refreshInfo);

	__ASSERT_DEBUG(terminalRespData && refreshInfo, CtsyDispatcherPanic(EInvalidNullPtr));
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatRefreshAllowed)
		{
		ret = iLtsyDispatchSatRefreshAllowed->HandleRefreshAllowedReqL(refreshInfo->iFileList,
																		refreshInfo->iAid,
																		refreshInfo->iInternalCache);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchServiceRequestL

TInt CSatDispatcher::DispatchReadyL()
/**
 * Unpack data related to ESatTsyReady
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatReady)
		{
		ret = iLtsyDispatchSatReady->HandleReadyReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchReadyL

TInt CSatDispatcher::DispatchPCmdNotificationL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsyGetIfPendingNotification
 * 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));
	TUint8 commandtype = 0;
	aDataPackage->UnPackData(commandtype);

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatPCmdNotification)
		{
		ret = iLtsyDispatchSatPCmdNotification->HandlePCmdNotificationReqL(commandtype);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchPCmdNotificationL

TInt CSatDispatcher::DispatchUssdControlEnvelopeErrorL()
/**
 * Unpack data related to ESatTsyEnvelopeError
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatUssdControlEnvelopeError)
		{
		ret = iLtsyDispatchSatUssdControlEnvelopeError->HandleUssdControlEnvelopeErrorReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchUssdControlEnvelopeErrorL

TInt CSatDispatcher::DispatchTimerExpiredL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTsyTimerExpiredIPC
 * 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));
	TPtrC8* timerExpirationEnvelope = NULL;
	aDataPackage->UnPackData(&timerExpirationEnvelope);
	__ASSERT_DEBUG(timerExpirationEnvelope, CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatTimerExpired) 
		{
		ret = iLtsyDispatchSatTimerExpired->HandleTimerExpirationEnvelopeReqL(*timerExpirationEnvelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchTimerExpiredL

TInt CSatDispatcher::DispatchTerminalRspL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatTerminalRsp
 * 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));
	TTerminalRespData* response = NULL;
	TPtrC8* resultAndAddInfoTlv = NULL;
	aDataPackage->UnPackData(&response, &resultAndAddInfoTlv);
	
	__ASSERT_DEBUG(response && resultAndAddInfoTlv, CtsyDispatcherPanic(EInvalidNullPtr));
	
	if (iLtsyDispatchSatTerminalRsp)
		{
		RBuf8 terminalRsp;
		CleanupClosePushL(terminalRsp);
		
		const TInt KDeviceIdentityLength = 4;
		terminalRsp.CreateL((response->iCommandDetails).Length() + KDeviceIdentityLength + resultAndAddInfoTlv->Length());
		
		//command details
		terminalRsp.Append(response->iCommandDetails);
		
		//device identity
		const TInt KDeviceIdentityDataLength = 2;
		terminalRsp.Append(KTlvDeviceIdentityTag);
		terminalRsp.Append(KDeviceIdentityDataLength);
		terminalRsp.Append(KMe);
		terminalRsp.Append(KSim);

		//result + additional data
		terminalRsp.Append(*resultAndAddInfoTlv);
		
		__ASSERT_DEBUG(terminalRsp.Length() <= KTlvMaxSize, CtsyDispatcherPanic(EBadLength));
		__ASSERT_DEBUG(terminalRsp.Length() == terminalRsp.MaxLength(), CtsyDispatcherPanic(EBadLength));
		
		ret = iLtsyDispatchSatTerminalRsp->HandleTerminalRspReqL(terminalRsp);
		
		CleanupStack::PopAndDestroy(&terminalRsp);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchTerminalRspL

TInt CSatDispatcher::DispatchMenuSelectionL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatMenuSelection
 * 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));

	TPtrC8* envelope = NULL;
	aDataPackage->UnPackData(&envelope);
	__ASSERT_DEBUG(envelope, CtsyDispatcherPanic(EInvalidNullPtr));
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatMenuSelection)
		{
		ret = iLtsyDispatchSatMenuSelection->HandleMenuSelectionEnvelopeReqL(*envelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchMenuSelectionL

TInt CSatDispatcher::DispatchEventDownloadL(const CMmDataPackage* aDataPackage)
/**
 * Unpack data related to ESatEventDownload
 * 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));
	TPtrC8* envelope = NULL;
	aDataPackage->UnPackData(&envelope);
	
	__ASSERT_DEBUG(envelope, CtsyDispatcherPanic(EInvalidNullPtr));
	
	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatEventDownload) 
		{
		ret = iLtsyDispatchSatEventDownload->HandleEventDownloadEnvelopeReqL(*envelope);
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchEventDownloadL

TInt CSatDispatcher::DispatchGetUssdControlSupportedL()
/**
 * Unpack data related to ESatTsyUssdControlSupported
 * 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;

	// Call Handle... method in Licensee LTSY
	if (iLtsyDispatchSatGetUssdControlSupported)
		{
		ret = iLtsyDispatchSatGetUssdControlSupported->HandleGetUssdControlSupportedReqL();
		}

	return TSYLOGSETEXITERR(ret);
	} // CSatDispatcher::DispatchEventDownloadL


//
// Callback handlers follow
//



void CSatDispatcher::CallbackUssdControlSupported(TInt aError, TBool aSupported)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatGetUssdControlSupportedComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aSupported whether or not USSD-TLV is supported
 *  in the (u)sim service table
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aSupported=%d"), aError, aSupported);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&aSupported);
	
	iMessageManagerCallback.Complete(ESatTsyUssdStatus, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackUssdControlSupported

void CSatDispatcher::CallbackPcmd(TInt aError, const TDesC8& aData)
/**
 * Callback function to be used by the request to complete.
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aData TLV data received from the SIM that contains the proactive command.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	__DEBUG_ONLY(const TUint8 KCommandUiccTagIndex  = 0;)
	__ASSERT_DEBUG(aData[KCommandUiccTagIndex] == KBerTlvProactiveSimCommandTag, CtsyDispatcherPanic(ECorruptTlvData));

	TPtrC8 dataPtr(aData);
	
	// Pack the data to return to the Common TSY
    CMmDataPackage dataPackage;
	dataPackage.PackData(&dataPtr);
	
	iMessageManagerCallback.Complete(ESatTsyPCmd, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackPcmd

void CSatDispatcher::CallbackNotifyProactiveSimSessionEnd(TInt aError,TUint8 aStatusWord1, TUint8 aStatusWord2)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatNotifyProactiveSimSessionEndInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aStatusWord1 The Status Word 1
 * @param aStatusWord2 The Status Word 2
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aStatusWord1=%d,aStatusWord2=%d"), aError, aStatusWord1, aStatusWord2);

	CMmDataPackage dataPackage;
	dataPackage.PackData(&aStatusWord1,&aStatusWord2);
	
	iMessageManagerCallback.Complete(ESatNotifyProactiveSimSessionEnd, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackNotifyProactiveSimSessionEnd

void CSatDispatcher::CallbackTimeZoneChange(TInt aError, TUint8 aTimeZone)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatTimeZoneChangeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aTimeZone The new time zone coded as defined in "ETSI TS 123 040" "TP-Service-Centre-Time-Stamp" 
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aTimeZone=%d"), aError, aTimeZone);

	CMmDataPackage dataPackage;
	dataPackage.PackData(&aTimeZone);

	iMessageManagerCallback.Complete(ESatTsyTimeZone, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackTimeZoneChange

void CSatDispatcher::CallbackAccessTechnologyChange(TInt aError, TUint8 aCurrentAccessTechnology)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatAccessTechnologyChangeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aCurrentAccessTechnology The current access technology being used by the terminal
 * See "ETSI TS 102 223" "Access technology"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCurrentAccessTechnology=%d"), aError, aCurrentAccessTechnology);

	CMmDataPackage dataPackage;
	dataPackage.PackData(&aCurrentAccessTechnology);
	
	iMessageManagerCallback.Complete(ESatTsyAccessTechnologyChange, &dataPackage, aError);
	} // CSatDispatcher::CallbackAccessTechnologyChange

void CSatDispatcher::CallbackCallConnected(TInt aError, TUint8 aTransactionId, TBool aNearEnd)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatCallConnectedInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aTransactionId The Transaction Identifier in the call connect message.
 * @param aIsNearEnd If True, the case of connecting is at the near end (an MT call), (i.e. source = terminal, destination = UICC)
 * 					 If False (i.e. far end), the case of connecting is at the far end (an MO call), (i.e. source = network, destination = UICC)
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d, aTransactionId=%d, aNearEnd=%d"),aError,aTransactionId,aNearEnd);

	CMmDataPackage dataPackage;
	dataPackage.PackData(&aTransactionId,&aNearEnd);
	
	iMessageManagerCallback.Complete(ESatTsyCallConnected, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackCallConnected

void CSatDispatcher::CallbackSsChange(TInt aError, DispatcherSat::TSsStatus aStatus)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatSsChangeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aStatus whether SS or USSD is busy
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d, aStatus=%d"), aError, aStatus);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	
	//switch here to convert from DispatcherSat::TSsStatus to TSsStatus
	//could static cast from DispatcherSat::TSsStatus to TSsStatus be would
	//need to ensure DispatcherSat::TSsStatus enums always matchs TSsStatus enums.
	TSsStatus status;
	
	switch(aStatus)
		{
		case DispatcherSat::ENotBusy:
			status = ENotBusy;
			break;
		case DispatcherSat::ESsBusy:
			status = ESsBusy;
			break;
		case DispatcherSat::EUssdBusy:
			status = EUssdBusy;
			break;
		}
	
	dataPackage.PackData(&status);
	
	iMessageManagerCallback.Complete(ESatTsySsStatus, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackSsChange

void CSatDispatcher::CallbackCallDisconnected(TInt aError, TUint8 aTransactionId, TBool aNearEnd, const TDesC8& aCause)
/**
 * Callback function to be used by the request to complete 
 * CCtsyDispatcherCallback::CallbackSatCallDisconnectedInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aTransactionId The Transaction Identifier of the call being disconnected.
 * @param aIsNearEnd If True, the case of disconnection is at the near end, (i.e. source = terminal, destination = UICC)
 * 					If False (i.e. far end), the case of disconnection is at the far end, (i.e. source = network, destination = UICC)
 * @param aCause 	The cause value is defined in the appropriate access technology specification. 
 * 					Radio Link Timeout is indicated by the cause having zero length, the maximum length is defined in KMaxCauseLength
 * 					See "ETSI TS 102 223" "COMPREHENSION-TLV data objects" "Cause"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aTransactionId=%d,aNearEnd=%d"), aError,aTransactionId,aNearEnd);

	__ASSERT_DEBUG(aCause.Length() <= KMaxCauseLength, CtsyDispatcherPanic(EBadLength));
	
	TCallDisconnectedEnvelope callDisconnectedEnvelope;
	callDisconnectedEnvelope.iCmdNumber  = aTransactionId;
	callDisconnectedEnvelope.iNearEnd	 = aNearEnd;
	callDisconnectedEnvelope.iCauseGiven = (aCause.Length() != 0);
	callDisconnectedEnvelope.iCause		 = aCause;
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&callDisconnectedEnvelope);
	iMessageManagerCallback.Complete(ESatTsyCallDisconnected, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackCallDisconnected

void CSatDispatcher::CallbackMtCall(
		TInt aError, TUint8 aTransactionId, const TDesC8& aAddress, const TDesC8& aSubAddress)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatMtCallInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aTransactionId The Transaction Identifier in the call setup message from the network.
 * @param aAddress Holds the Calling Party number received by the terminal in the call setup message. If
 * the Calling Party number is included in the call setup message, the Address shall be included, otherwise
 * the address shall not be included  (zero length). See "ETSI TS 102 223" "COMPREHENSION-TLV data objects" "Address" 
 * @param aSubAddress Holds the Calling Party Subaddress as received by the terminal in the call setup
 * message. If the Calling Party Subaddress is included in the call setup message, the Subaddress shall be included, otherwise 
 * the Subaddress shall not be included (zero length). See "ETSI TS 102 223" "COMPREHENSION-TLV data objects" "Subaddress"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aTransactionId=%d"),aError,aTransactionId);

	const TInt KTonAndNpiIndex = 0;
	const TInt KTonAndNpiLength = 1;
	
	TMTCallEnvelope mtCallEnvelope;
	
	mtCallEnvelope.iCmdNumber = aTransactionId;
	
	//according to TS 24.008. If the Dialling Number/SSC String does not contain a dialling number, e.g. a control
	//string deactivating a service, the TON/NPI byte shall be set to 'FF' by the ME, but..
	//the CTSY expects it to be zero to indicate it is missing

	// chop so that it fits within the buffer (if required)
	TPtrC8 truncAddress = aAddress.Left(KNumberMaxLength + KTonAndNpiLength);
	mtCallEnvelope.iTONandNPI = (truncAddress.Length() >= KTonAndNpiLength) ? truncAddress[KTonAndNpiIndex] : 0;

	// extract the dialling number (address minus the Ton & Npi)
	mtCallEnvelope.iDiallingNumber = truncAddress.Mid(KTonAndNpiLength);
		
	mtCallEnvelope.iCalledPartySubAddress.Set(aSubAddress);
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&mtCallEnvelope);
	
	iMessageManagerCallback.Complete(ESatTsyMTCall, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackMtCall

void CSatDispatcher::CallbackCallControlEnvelopeResponse(TInt aError, const TDesC8& aResponseTlv)
/**
 * Callback function to be used by the request to allow the RSat client to display any alpha identifiers
 * resulting from call control.
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aResponseTlv the response from NAA to the ENVELOPE (CALL CONTROL) command. This will be parsed by the CTSY
 * and if an alpha identifier exists in the data, it will be passed to the RSat client (if any) for display to the 
 * user. As per ETSI 102.223 section 7.3.1.6, this contains 1 byte containing the Call Control result, followed by a 
 * 1-2 byte length, then various optional fields depending on the outcome of the Call/SS/USSD Control. If the NAA
 * application does not provide any response data then this is interpreted as "allowed, no modification".
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	TUint8 callControlResult = 0; 
	if (aResponseTlv.Length() > 0) //no response data is interpreted as allowed no modification
		{
		callControlResult = aResponseTlv[0];
		}
	
	RSat::TControlResult res;
	switch (callControlResult)
		{
		case 2:
			{	
			res = RSat::EAllowedWithModifications;
			}
			break;
		case 1:
			{
			res = RSat::ENotAllowed;
			}
			break;
		case 0:
		default: //default case is invalid
			{
			res = RSat::EAllowedNoModification;
			}
			break;
		}
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&const_cast<TDesC8&>(aResponseTlv), &res);
	    
	iMessageManagerCallback.Complete(ESatTsyCheckAtkDataForAlphaId, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackCallControlEnvelopeResponse

void CSatDispatcher::CallbackCreateCallControlEnvelope(TInt aError, TUint8 aTag, const TDesC8& aBcc1, const TDesC8& aBcc2, 
			const TDesC8& aAddress, TUint8 aTonNpi, TUint8 aDcs)
/**
 * Callback function to be used by the request to complete.
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aCallControlInfo details of the Call/SS/USSD request that is being passed to UICC for possible Control
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	__ASSERT_DEBUG(aBcc1.Length() < KMaxBccLength, CtsyDispatcherPanic(EBadLength));
	__ASSERT_DEBUG(aBcc2.Length() < KMaxBccLength, CtsyDispatcherPanic(EBadLength));
	__ASSERT_DEBUG(aAddress.Length() < KMaxAddressLength, CtsyDispatcherPanic(EBadLength));
	
	TCCInfo ccInfo;
	ccInfo.iTag = aTag;
	ccInfo.iBcc1 = aBcc1;
	ccInfo.iBcc2 = aBcc2;
	ccInfo.iAddress = aAddress;
	ccInfo.iTonNpi = aTonNpi;
	ccInfo.iDcs = aDcs;

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&ccInfo);
	
	iMessageManagerCallback.Complete(ESatTsyCreateEnvelope, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackCreateCallControlEnvelope

void CSatDispatcher::CallbackCreateSmControlEnvelope(TInt aError, const TDesC8& aRpDestinationAddress, const TDesC8& aTpDestinationAddress)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatCreateSmControlEnvelopeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aRpDestinationAddress RP Destination Address of the Service Center to which the ME is proposing to send the short message.
 * @param aTpDestinationAddress TP Destination Address to which the ME is proposing to send the short message.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	TAddressData addressData;
	addressData.iRPDestinationAddr.Set(aRpDestinationAddress);
	addressData.iTPDestinationAddr.Set(aTpDestinationAddress);
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&addressData);
	
	iMessageManagerCallback.Complete(ESatTsyMoSmControlEnvelope, &dataPackage, aError);
	} // CSatDispatcher::CallbackCreateSmControlEnvelope

void CSatDispatcher::CallbackImsiChanged(TInt aError)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatImsiChangedInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	iMessageManagerCallback.Complete(ESatTsyImsiChanged, aError);
	
	} // CSatDispatcher::CallbackImsiChanged

void CSatDispatcher::CallbackLocationStatus(TInt aError, TUint8 aLcnStatus, 
		const TDesC8& aCountryCode, TUint16 aLcnAreaCode, TUint16 aCellId)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatLocationStatusInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aLcnStatus the current service state of the terminal - 
 * 			one of the values defined in ETSI 102.223 section 8.27
 * @param aCountryCode 3 digit string (numerical) uniquely identifying the country. The length of 
 * this descriptor should be 3.
 * @param aLcnAreaCode The Location Area Code uniquely identifies a Location Area 
 * 			with a network. 
 * @param aCellId The current cell.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	__ASSERT_DEBUG(aCountryCode.Length() <= KCountryCodeLength, CtsyDispatcherPanic(EBadLength));
	
	// Pack the data to return to the Common TSY to construct possible EVENT DOWNLOAD envelope 
	TLocationStatusEnvelope lcnStatEnv;
	lcnStatEnv.iLocationStatus = aLcnStatus;
	lcnStatEnv.iCountryCode = aCountryCode;
	lcnStatEnv.iLocationAreaCode = aLcnAreaCode;
	lcnStatEnv.iCellId = aCellId;
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&lcnStatEnv);
	
	iMessageManagerCallback.Complete(ESatTsyLocationStatus, &dataPackage, aError);
	
	//Pack the data to return to the Common TSY to cache for use in Call/SS/USSD control envelopes
	TLocalInformation localInfo;
	localInfo.iLocationAreaCode = aLcnAreaCode;
	localInfo.iCellId = aCellId;
	localInfo.iOperatorCode = aCountryCode;
	
	dataPackage.PackData(&localInfo);
	
	iMessageManagerCallback.Complete(ESatTsyProvideLocalInfo, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackLocationStatus

void CSatDispatcher::CallbackRemoveEventList(TInt aError)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatRemoveEventListInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	iMessageManagerCallback.Complete(ESatTsyRemoveEventList, aError);
	
	} // CSatDispatcher::CallbackRemoveEventList

void CSatDispatcher::CallbackCreateRefreshTerminalRsp(TInt aError, RSat::TPCmdResult aGeneralResult, const TDesC& aResultAdditionalInfo)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatCreateRefreshTerminalRspInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aGeneralResult The General result that specifies the result and indicates appropriate UICC action (to be included in the 
 * refresh terminal response result section, see ETSI 102 223 Under "Structure of TERMINAL RESPONSE" and Under "Result")
 * @param aResultAdditionalInfo Additional information (to be included in the refresh terminal response result section, 
 * see ETSI 102 223 Under "Structure of TERMINAL RESPONSE" and Under "Result")
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aGeneralResult=%d"), aError, aGeneralResult);

	__ASSERT_DEBUG(aResultAdditionalInfo.Length() <= RSat::KAdditionalInfoMaxSize, CtsyDispatcherPanic(EBadLength));
	
	TTerminalRespData terminalRespData;
	terminalRespData.iGeneralResult = aGeneralResult;
	terminalRespData.iAdditionalInfo = aResultAdditionalInfo;	

	CMmDataPackage dataPackage;
	dataPackage.PackData(&terminalRespData);
	
	iMessageManagerCallback.Complete(ESatTsyRefresh, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackCreateRefreshTerminalRsp

void CSatDispatcher::CallbackSmControlEnvelopeResponse(TInt aError, const TDesC8& aResponseTlv)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatSmControlEnvelopeResponseInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aResponseTlv Response data from the SIM encoded as defined in "3GPP 11.14 - MO Short Message Control by SIM"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&const_cast<TDesC8&>(aResponseTlv));
	
	iMessageManagerCallback.Complete(ESatNotifyMoSmControlRequest, &dataPackage, aError);

	} // CSatDispatcher::CallbackSmControlEnvelopeResponse

void CSatDispatcher::CallbackSatCreateSmsPpDownloadEnvelope(TInt aError, const TDesC8& aRpOriginatingAddress, const TDesC8& aSmsDeliveryTpdu)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatCreateSmsPpDownloadEnvelopeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aRpOriginatingAddress RP Originating Address of the Service Centre (TS Service-Centre-Address), as defined in 3GPP TS 24.011)
 * @param aSmsDeliveryTpdu The SMS-DELIVER TPDU (See "3GPP 23.040" under "SMS DELIVER type")
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	__ASSERT_DEBUG(aRpOriginatingAddress.Length() + 1 <= KAddrMaxLength, CtsyDispatcherPanic(EBadLength));
	__ASSERT_DEBUG(aSmsDeliveryTpdu.Length() <= RMobileSmsMessaging::KGsmTpduSize, CtsyDispatcherPanic(EBadLength));
	
	//The SIM ATK CTSY takes an Rp Address with the address length prefixed to the adress (this is 
	//eventually calculated when constructing the TLV envelope and not used when SmsPp Download
	//is supported, but used when construdting the Ef(Sms) (SmsPP Download not supported))
	//The code below takes the address and process it into the format the SIM ATK CTSY expects

	TBuf8<KAddrMaxLength> address;
	
	//chop to the the max buffer size (-1 for the length)
	TPtrC8 trucRpOriginatingAddress = aRpOriginatingAddress.Left(KAddrMaxLength - 1);
	address.Append(trucRpOriginatingAddress.Length());
	address.Append(trucRpOriginatingAddress);
		
	CMmDataPackage dataPackage;
	dataPackage.PackData(&address,&const_cast<TDesC8&>(aSmsDeliveryTpdu));
	
	//the error code is not currently used in the SIM ATK TSY
	iMessageManagerCallback.Complete(ESatTsySmsPpDdl, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackSatCreateSmsPpDownloadEnvelope

void CSatDispatcher::CallbackCreateSmsDeliverReport(TInt aError)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatCreateSmsDeliverReportInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	iMessageManagerCallback.Complete(ESatTsySmsDeliverReport, aError);
	
	} // CSatDispatcher::CallbackCreateRefreshTerminalRsp

void CSatDispatcher::CallbackCreateCellBroadcastEnvelope(TInt aError, const TDesC8& aCellBroadcastPage)
/**
 * Callback function to be used by the request to complete CCCtsyDispatcherCallback::CallbackSatCreateCellBroadcastEnvelopeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aCellBroadcastPage The Cell Broadcast page, formatted in the same way as described in 3GPP TS 23.041
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	__ASSERT_DEBUG(aCellBroadcastPage.Length() <= KCbsMsgMaxLength, CtsyDispatcherPanic(EBadLength));

	//the SIM ATK CTSY unpacks to a TBuf8 (of the stack) of maxlength KCbsMsgMaxLength
	TPtrC8 cellBroadcastPage = aCellBroadcastPage.Left(KCbsMsgMaxLength);
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&cellBroadcastPage);
		
	iMessageManagerCallback.Complete(ESatTsyCellBroadcast, &dataPackage, aError);
	} // CSatDispatcher::CallbackCreateCellBroadcastEnvelope


void CSatDispatcher::CallbackGetImageInstance(TInt aError, 
		const TDesC8& aImageInstanceData, const TDesC8& aImageInstanceBody)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatGetImageInstanceComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aImageInstanceData 	Descriptor containing the image instance coding scheme of the EF(IIDF),
 * 								this must be of length 2 (KBasicIconDataLength) for basic 
 * 								or length 6 (KColourIconDataLength) for colour image instances.
 * 								See ETSI TS 131 102 under "Annex B (normative) Image Coding Schemes (B.1 & B.2)"
 * @param aImageInstanceBody	Descriptor containing the image instance body of the EF(IIDF)
 * 								See ETSI TS 131 102 under "Annex B (normative) Image Coding Schemes"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	switch(aImageInstanceData.Length())
		{
		case KBasicIconDataLength:
			{
			//copy aImageInstanceData to a KColourIconDataLength (6) byte descriptor, 
			//the CTSY expects a length of KColourIconDataLength even if only 2 bytes are used,
			//for a basic image.
			TBuf8<KColourIconDataLength> imageInstanceData(aImageInstanceData);
			imageInstanceData.SetMax();
			
			// Pack the data to return to the Common TSY
			CMmDataPackage dataPackage;
			dataPackage.PackData(&const_cast<TDesC8&>(aImageInstanceBody),&imageInstanceData);
			iMessageManagerCallback.Complete(ESatTsyGetImageInstance, &dataPackage, aError);			
			break;
			}
		
		case KColourIconDataLength:
			{
			// Pack the data to return to the Common TSY
			CMmDataPackage dataPackage;
			dataPackage.PackData(&const_cast<TDesC8&>(aImageInstanceBody),&const_cast<TDesC8&>(aImageInstanceData));
			iMessageManagerCallback.Complete(ESatTsyGetImageInstance, &dataPackage, aError);
			break;
			}
		
		default:
			{
			// The descriptor length should be either 2 for basic (KBasicIconDataLength)
			// or 6 for colour (KColourIconDataLength)
			__ASSERT_DEBUG(EFalse, CtsyDispatcherPanic(EBadLength));
			}
		}
	} // CSatDispatcher::CallbackGetImageInstance

void CSatDispatcher::CallbackGetIconData(TInt aError, const TDesC8& aIconEfImgRecord)
/**
 * Callback function to be used by the request to complete.
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError 			The error code to be returned to the CTSY Dispatcher.
 * @param aIconEfImgRecord  The icon EF(Img) record retrieved from the UICC
 * 							See ETSI TS 131 102 under "Contents of files at the DFGRAPHICS level"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	// Pack the data to return to the Common TSY
	CMmDataPackage iconEfImgRecordPkg;
	iconEfImgRecordPkg.PackData(&const_cast<TDesC8&>(aIconEfImgRecord));
	
	iMessageManagerCallback.Complete(ESatTsyGetIconData, &iconEfImgRecordPkg, aError);
	
	} // CSatDispatcher::CallbackGetIconData

void CSatDispatcher::CallbackGetClut(TInt aError, const TDesC8& aClut)
/**
 * Callback function to be used by the request to complete  CCtsyDispatcherCallback::CallbackSatGetClutComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError 	The error code to be returned to the CTSY Dispatcher.
 * @param aClut 	The requested CLUT (Colour look up table) for a given icon instance
 * 					See ETSI TS 131 102 under "B.2 Colour Image Coding Scheme"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	// Pack the data to return to the Common TSY
	CMmDataPackage clutPkg;
	clutPkg.PackData(&const_cast<TDesC8&>(aClut));
	iMessageManagerCallback.Complete(ESatTsyGetClut, &clutPkg, aError);
	} // CSatDispatcher::CallbackGetClut

void CSatDispatcher::CallbackGetDefaultBearerCapability(TInt aError,
		const TDesC8& aCapability)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatGetDefaultBearerCapabilityComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aCapability The default bearer capability configuration (see 3GPP TS 04.08 for info about 
 * bearer capability), this may be used by the CTSY when creating a Call Control ENVELOPE if a zero 
 * length capability parameter is supplied with the Envelope creation request.  
 * Note the maximum length capability the CTSY can store is 248, and a maximum length of 16 will be 
 * used in the creation of the Call Control ENVELOPE.
 *
 * See "ETSI TS 102 223" "Structure of ENVELOPE (CALL CONTROL)" 
 * See "3GPP TS 04.08"
 * @see CSatDispatcher::CallbackSatCreateCallControlEnvelopeInd()
 * 
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	//debug assert if the capability is to long, otherwise in release mode
	//chop it down to the max buffer length to prevent the SIM ATK from panicing
	__ASSERT_DEBUG(aCapability.Length() <= KMaxLengthDefaultBearerData, CtsyDispatcherPanic(EBadLength));
	TPtrC8 beareraCapability(aCapability.Left(KMaxLengthDefaultBearerData));
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&beareraCapability);
	
	iMessageManagerCallback.Complete(ESatTsyGetBearerCapability, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackGetDefaultBearerCapability

void CSatDispatcher::CallbackGetSmsPpDownloadSupported(TInt aError, TBool aSupported)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatGetSmsPpDownloadSupportedComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aSupported If the service "data download via SMS Point-to-point" is allocated and activated in the SIM Service Table 
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aSupported=%d"), aError, aSupported);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&aSupported);
	
	iMessageManagerCallback.Complete(ESatTsySmsPpDdlStatus, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackGetSmsPpDownloadSupported

void CSatDispatcher::CallbackGetSmsControlActivated(TInt aError, TBool aActivated)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatGetSmsControlActivatedComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aActivated True if MO-SMS Control by USIM (Service n°31) is currently activated (by the USIM),
 * False otherwise
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aActivated=%d"), aError, aActivated);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&aActivated);	
	iMessageManagerCallback.Complete(ESatTsyMoSmsControlActivation, &dataPackage, aError);
	
	} // CSatDispatcher::CallbackGetSmsControlActivated

void CSatDispatcher::CallbackTimingAdvance(TInt aError,
		TUint8 aTimingAdvance, TUint8 aMeStatus)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatTimingAdvanceComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aTimingAdvance a value relating to the distance between the ME and the base station. This is used
 * to compensate for propagation delay.
 * @param aMeStatus Whether or not the ME is idle...this is to allow the application to know whether the
 * timing advance is based on current or cached information.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aTimingAdvance=%d,aMeStatus=%d"), aError, aTimingAdvance, aMeStatus);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&aTimingAdvance, &aMeStatus);
	
	iMessageManagerCallback.Complete(ESatTsyTimingAdvance, &dataPackage, aError);
	
	//send off the in progress terminal response now that we have collected the required information for it.
	CompleteNotifyLocalInfo(aError);

	
	} // CSatDispatcher::CallbackTimingAdvance

void CSatDispatcher::CallbackGetAccessTechnology(TInt aError, TUint8 aAccessTechnology)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatAccessTechnologyChangeInd().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aAccessTechnology The current access technology being used by the terminal
 * See "ETSI TS 102 223" "Access technology"
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aAccessTechnology=%d"), aError, aAccessTechnology);

	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(&aAccessTechnology);
	
	iMessageManagerCallback.Complete(ESatTsyAccTech, &dataPackage, aError);
	
	//send off the in progress terminal response now that we have collected the required information for it.
	CompleteNotifyLocalInfo(aError);

	
} // CSatDispatcher::CallbackGetAccessTechnology

void CSatDispatcher::CallbackProvideLocationInfo(TInt aError, TUint16 aLocationAreaCode, 
		TUint16 aCellId, const TDesC8& aOperatorCode)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatProvideLocationInfoComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aLocationAreaCode the ID of the Location Area (grouping of multiple cells)
 * that the mobile is in 
 * @param aCellId Id of the current GSM cell
 * @param aOperatorCode Id of the current operator. This has a maximum length of 3.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aLocationAreaCode=%d,aCellId=%d"), aError, aLocationAreaCode, aCellId);

	__ASSERT_DEBUG(aOperatorCode.Length() <= KOperatorCodeLength, CtsyDispatcherPanic(EBadLength));

	
	// Pack the data to return to the Common TSY
	TLocalInformation localInfo;
	localInfo.iLocationAreaCode = aLocationAreaCode;
	localInfo.iCellId = aCellId;
	localInfo.iOperatorCode = aOperatorCode;
	CMmDataPackage dataPackage;
	dataPackage.PackData(&localInfo);
	
	iMessageManagerCallback.Complete(ESatTsyProvideLocalInfo, &dataPackage, aError);
	
	//send off the in progress terminal response now that we have collected the required information for it.
	CompleteNotifyLocalInfo(aError);

	
	} // CSatDispatcher::CallbackProvideLocationInfo

void CSatDispatcher::CallbackSetPolling(TInt aError, TUint8 aPollingInterval)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatSetPollingIntervalComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aPollingInterval The polling interval in use by the LTSY (zero) indicate Polling is off. This will be used
 * in the terminal response to the original Polling Interval / Polling Off proactive command.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d,aPollingInterval=%d"), aError, aPollingInterval);

	//this proactive command number will be used in the CTSY to fill in TTerminalRespData's iPCmdNumber field,
	//the CTSY expects the LTSY to supply this.
	//As now the terminal response structure is created from the iCommandDetails which contains the
	//proactive command number anyway the dispatcher no longer needs to hide this from teh interface
	//with a cache and can just send up any number
	TUint8 pcmdNumber = 0;

	CMmDataPackage dataPackage;
	dataPackage.PackData(&pcmdNumber,&aPollingInterval);
	
	iMessageManagerCallback.Complete(ESatTsySetPolling, &dataPackage, aError);

	} // CSatDispatcher::CallbackSetPolling


void CSatDispatcher::CallbackLocalInformationNmr(TInt aError,
			const TDesC8& aNmr, const TDesC& aBcchList)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatLocalInformationNmrComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 * @param aNmr - Network Measurement Results - reception level of BCCH of adjacent cells  
 * @param aBcchList - Broadcast Control Channel List - the Broadcast Control Channel 
 * of neighbouring cells (in 16-bit format, will be converted to 10-bit in CTSY).
 * 
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	__ASSERT_DEBUG(aNmr.Length() <= KNmrLength, CtsyDispatcherPanic(EBadLength));
	__ASSERT_DEBUG(aBcchList.Length() <= KBcchListLength, CtsyDispatcherPanic(EBadLength));
	
	// Pack the data to return to the Common TSY
	CMmDataPackage dataPackage;
	dataPackage.PackData(const_cast<TDesC8*>(&aNmr),const_cast<TDesC*>(&aBcchList));

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

	//send off the in progress terminal response now that we have collected the required information for it.
	CompleteNotifyLocalInfo(aError);
	
	} // CSatDispatcher::CallbackLocalInformationNmr

void CSatDispatcher::CallbackRefreshAllowed(TInt aError)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatRefreshAllowedComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher and SAT client.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	//the SAT TSY
	iMessageManagerCallback.Complete(ESatTsyCompleteRefresh, aError);

	//custom TSY (will do nothing when custom TSY is not open)
	iTsyMessageManagerCallback.Complete(ECustomSatRefreshCompleteNotificationIPC, aError);
	
	} // CSatDispatcher::CallbackRefreshAllowed

void CSatDispatcher::CallbackReady(TInt aError)
/**
 * Callback function to be used by the request to completeCCtsyDispatcherCallback::CallbackSatReadyComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	iMessageManagerCallback.Complete(ESatTsyReady, aError);
	
	} // CSatDispatcher::CallbackReady

void CSatDispatcher::CallbackUssdControlEnvelopeError(TInt aError)
/**
 * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSatUssdControlEnvelopeErrorComp().
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	iMessageManagerCallback.Complete(ESatTsyEnvelopeError, aError);
	
	} // CSatDispatcher::CallbackUssdControlEnvelopeError

void CSatDispatcher::CallbackTerminalRsp(TInt aError)
/**
 * Callback function to be used by the request to complete.
 *
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.
 *
 * @param aError The error code to be returned to the CTSY Dispatcher.
 */
	{
	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
	
	TBool onGoing = (aError == KErrNone) ? FALSE : TRUE;
	
	CMmDataPackage dataPackage;
	dataPackage.PackData(&onGoing);

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

	} // CSatDispatcher::CallbackTerminalRsp

void CSatDispatcher::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.
 *  
 * This function is optional and should only be used if the licensee wishes to including the Dispatcher beneath their own SIM ATK TSY.  
 *  
 * @param aIpcDataPackage Package encapsulating the request.
 * 
 * @see MDispatcherCallback::CallbackSync
 */
	{
	TSYLOGENTRYEXIT;
	
	switch (aIpcDataPackage.iIpc)
		{
	
	default:
		LOG(_L8("WARNING: CSatDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc);
		__ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc));
		break;		
		} // switch (aIpcDataPackage.iIpc)
	
	} // CSatDispatcher::CallbackSync



