// 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::CSatDispatcherCSatDispatcher::~CSatDispatcher() { } // CSatDispatcher::~CSatDispatcherCSatDispatcher* 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::NewLCCSatDispatcher* 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::NewLvoid 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::ConstructLvoid 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::IsSimOriginatedCallvoid 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::CompleteNotifyLocalInfoTInt 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::DispatchSmsDeliverReportLTInt 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::DispatchGetImageInstanceLTInt 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::DispatchGetIconDataLTInt 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::DispatchGetClutLTInt 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::DispatchGetDefaultBearerCapabilityLTInt 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::DispatchSmsPpDdlStatusLTInt 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::DispatchGetSmsControlActivatedLTInt 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::DispatchCellBroadcastLTInt 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::DispatchAccessTechnologyLTInt 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::DispatchTimingAdvanceLTInt 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::DispatchNotifySmControlRequestLTInt 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::DispatchProvideLocationInfoLTInt 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::DispatchSetPollingIntervalLTInt 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::DispatchSmsPpDdlLTInt 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::DispatchLocalInformationNmrLTInt 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::DispatchSendEnvelopeLTInt 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::DispatchServiceRequestLTInt 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::DispatchReadyLTInt 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::DispatchPCmdNotificationLTInt 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::DispatchUssdControlEnvelopeErrorLTInt 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::DispatchTimerExpiredLTInt 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::DispatchTerminalRspLTInt 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::DispatchMenuSelectionLTInt 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::DispatchEventDownloadLTInt 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::CallbackUssdControlSupportedvoid 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::CallbackPcmdvoid 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::CallbackNotifyProactiveSimSessionEndvoid 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::CallbackTimeZoneChangevoid 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::CallbackAccessTechnologyChangevoid 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::CallbackCallConnectedvoid 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::CallbackSsChangevoid 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::CallbackCallDisconnectedvoid 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::CallbackMtCallvoid 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::CallbackCallControlEnvelopeResponsevoid 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::CallbackCreateCallControlEnvelopevoid 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::CallbackCreateSmControlEnvelopevoid 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::CallbackImsiChangedvoid 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::CallbackLocationStatusvoid 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::CallbackRemoveEventListvoid 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::CallbackCreateRefreshTerminalRspvoid 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::CallbackSmControlEnvelopeResponsevoid 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::CallbackSatCreateSmsPpDownloadEnvelopevoid 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::CallbackCreateRefreshTerminalRspvoid 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::CallbackCreateCellBroadcastEnvelopevoid 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::CallbackGetImageInstancevoid 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::CallbackGetIconDatavoid 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::CallbackGetClutvoid 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::CallbackGetDefaultBearerCapabilityvoid 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::CallbackGetSmsPpDownloadSupportedvoid 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::CallbackGetSmsControlActivatedvoid 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::CallbackTimingAdvancevoid 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::CallbackGetAccessTechnologyvoid 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::CallbackProvideLocationInfovoid 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::CallbackSetPollingvoid 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::CallbackLocalInformationNmrvoid 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::CallbackRefreshAllowedvoid 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::CallbackReadyvoid 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::CallbackUssdControlEnvelopeErrorvoid 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::CallbackTerminalRspvoid 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