--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/src/csmsdispatcher.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,819 @@
+// 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 <ctsy/serviceapi/cmmsmsutility.h>
+#include "csmsdispatcher.h"
+
+#include <ctsy/ltsy/mltsydispatchsmsinterface.h>
+#include <ctsy/pluginapi/mmmessagemanagercallback.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+
+#include <ctsy/ltsy/ltsylogger.h>
+#include "ctsydispatcherpanic.h"
+#include "tdispatcherholder.h"
+
+CSmsDispatcher::CSmsDispatcher(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ : iLtsyFactoryV1(aLtsyFactory),
+ iMessageManagerCallback(aMessageManagerCallback),
+ iRequestAsyncOneShot(aRequestAsyncOneShot)
+ {
+ } // CSmsDispatcher::CSmsDispatcher
+
+
+CSmsDispatcher::~CSmsDispatcher()
+ {
+ if(iLtsyDataList)
+ {
+ iLtsyDataList->ResetAndDestroy();
+ delete iLtsyDataList;
+ }
+ } // CSmsDispatcher::~CSmsDispatcher
+
+
+CSmsDispatcher* CSmsDispatcher::NewLC(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ {
+ TSYLOGENTRYEXIT;
+ CSmsDispatcher* self =
+ new (ELeave) CSmsDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ } // CSmsDispatcher::NewLC
+
+
+CSmsDispatcher* CSmsDispatcher::NewL(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ {
+ TSYLOGENTRYEXIT;
+ CSmsDispatcher* self =
+ CSmsDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+ CleanupStack::Pop (self);
+ return self;
+ } // CSmsDispatcher::NewL
+
+
+void CSmsDispatcher::ConstructL()
+/**
+ * Second phase constructor.
+ */
+ {
+ TSYLOGENTRYEXIT;
+
+ // Get the Licensee LTSY interfaces related to Sms functionality
+ // from the factory
+
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId))
+ {
+ TAny* sendSatSmsInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId,
+ sendSatSmsInterface);
+ iLtsyDispatchSmsSendSatSms =
+ static_cast<MLtsyDispatchSmsSendSatSms*>(sendSatSmsInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsSendSatSms, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId))
+ {
+ TAny* getSmsStoreInfoInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId,
+ getSmsStoreInfoInterface);
+ iLtsyDispatchSmsGetSmsStoreInfo =
+ static_cast<MLtsyDispatchSmsGetSmsStoreInfo*>(getSmsStoreInfoInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsGetSmsStoreInfo, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsGetSmspList::KLtsyDispatchSmsGetSmspListApiId))
+ {
+ TAny* getSmspListInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsGetSmspList::KLtsyDispatchSmsGetSmspListApiId,
+ getSmspListInterface);
+ iLtsyDispatchSmsGetSmspList =
+ static_cast<MLtsyDispatchSmsGetSmspList*>(getSmspListInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsGetSmspList, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId))
+ {
+ TAny* nackSmsStoredInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId,
+ nackSmsStoredInterface);
+ iLtsyDispatchSmsNackSmsStored =
+ static_cast<MLtsyDispatchSmsNackSmsStored*>(nackSmsStoredInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsNackSmsStored, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId))
+ {
+ TAny* ackSmsStoredInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId,
+ ackSmsStoredInterface);
+ iLtsyDispatchSmsAckSmsStored =
+ static_cast<MLtsyDispatchSmsAckSmsStored*>(ackSmsStoredInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsAckSmsStored, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId))
+ {
+ TAny* resumeSmsReceptionInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId,
+ resumeSmsReceptionInterface);
+ iLtsyDispatchSmsResumeSmsReception =
+ static_cast<MLtsyDispatchSmsResumeSmsReception*>(resumeSmsReceptionInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsResumeSmsReception, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsSendSmsMessage::KLtsyDispatchSmsSendSmsMessageApiId))
+ {
+ TAny* sendSmsMessageInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsSendSmsMessage::KLtsyDispatchSmsSendSmsMessageApiId,
+ sendSmsMessageInterface);
+ iLtsyDispatchSmsSendSmsMessage =
+ static_cast<MLtsyDispatchSmsSendSmsMessage*>(sendSmsMessageInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsSendSmsMessage, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsSendSmsMessageNoFdnCheck::KLtsyDispatchSmsSendSmsMessageNoFdnCheckApiId))
+ {
+ TAny* sendSmsMessageNoFdnCheckInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsSendSmsMessageNoFdnCheck::KLtsyDispatchSmsSendSmsMessageNoFdnCheckApiId,
+ sendSmsMessageNoFdnCheckInterface);
+ iLtsyDispatchSmsSendSmsMessageNoFdnCheck =
+ static_cast<MLtsyDispatchSmsSendSmsMessageNoFdnCheck*>(sendSmsMessageNoFdnCheckInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsSendSmsMessageNoFdnCheck, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsSetMoSmsBearer::KLtsyDispatchSmsSetMoSmsBearerApiId))
+ {
+ TAny* setMoSmsBearerInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsSetMoSmsBearer::KLtsyDispatchSmsSetMoSmsBearerApiId,
+ setMoSmsBearerInterface);
+ iLtsyDispatchSmsSetMoSmsBearer =
+ static_cast<MLtsyDispatchSmsSetMoSmsBearer*>(setMoSmsBearerInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsSetMoSmsBearer, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSmsFuncUnitId, MLtsyDispatchSmsStoreSmspListEntry::KLtsyDispatchSmsStoreSmspListEntryApiId))
+ {
+ TAny* storeSmspListInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchSmsStoreSmspListEntry::KLtsyDispatchSmsStoreSmspListEntryApiId,
+ storeSmspListInterface);
+ iLtsyDispatchSmsStoreSmspListEntry =
+ static_cast<MLtsyDispatchSmsStoreSmspListEntry*>(storeSmspListInterface);
+ __ASSERT_DEBUG(iLtsyDispatchSmsStoreSmspListEntry, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ iLtsyDataList = new( ELeave ) CArrayPtrFlat< TSmsParameters >( 10 );
+
+ } // CSmsDispatcher::ConstructL
+
+void CSmsDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)
+/**
+ * Set the dispatcher holder.
+ *
+ * @param aDispatcherHolder Reference to dispatcher holder.
+ */
+ {
+ TSYLOGENTRYEXIT;
+
+ iDispatcherHolder = &aDispatcherHolder;
+ } // CSmsDispatcher::SetDispatcherHolder
+
+TInt CSmsDispatcher::DispatchActivateSmsRoutingL()
+/**
+ * Unpack data related to EMmTsyActivateSmsRouting
+ * This is not passed to LTSY but just completed by dispatch layer
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ // Trigger async one shot completer
+
+ CRequestQueueOneShot::TIpcDataPackage* dataPackage = new (ELeave) CRequestQueueOneShot::TIpcDataPackage;
+ dataPackage->iIpc = EMmTsyActivateSmsRouting;
+ dataPackage->iResultCode = KErrNone;
+ dataPackage->iDataPackage = NULL;
+ dataPackage->iDispatcherCallback = this;
+ iRequestAsyncOneShot.QueueRequest(*dataPackage);
+
+ return TSYLOGSETEXITERR(KErrNone);
+ } // CSmsDispatcher::DispatchActivateSmsRoutingL
+
+
+TInt CSmsDispatcher::DispatchSendSatSmsL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsySmsSendSatMessage
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ TSendSmsDataAndAttributes* data = NULL;
+ aDataPackage->UnPackData(&data);
+
+ __ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iAttributes, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iMsgData, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsSendSatSms)
+ {
+ ret = iLtsyDispatchSmsSendSatSms->HandleSendSatSmsReqL( *(data->iMsgData),
+ (data->iAttributes->iDataFormat),
+ (data->iAttributes->iGsmServiceCentre),
+ (data->iAttributes->iMore)
+ );
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchSendSatSmsL
+
+TInt CSmsDispatcher::DispatchGetSmsStoreInfoL()
+/**
+ * @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 (iLtsyDispatchSmsGetSmsStoreInfo)
+ {
+ ret = iLtsyDispatchSmsGetSmsStoreInfo->HandleGetSmsStoreInfoReqL();
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchGetSmsStoreInfoL
+
+TInt CSmsDispatcher::DispatchGetSmspListL()
+/**
+ * @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 (iLtsyDispatchSmsGetSmspList)
+ {
+ ret = iLtsyDispatchSmsGetSmspList->HandleGetSmspListReqL();
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchGetSmspListL
+
+TInt CSmsDispatcher::DispatchNackSmsStoredL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingNackSmsStored
+ * and pass request on to Licensee LTSY.
+ *
+ * @param aDataPackage Contains packed pointer to TDesC8 (TPDU data) and TInt (RP cause)
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsNackSmsStored)
+ {
+ TDesC8* msgPtr = NULL;
+ TInt rpCause;
+ aDataPackage->UnPackData(msgPtr, rpCause);
+
+ if(msgPtr)
+ {
+ ret = iLtsyDispatchSmsNackSmsStored->HandleNackSmsStoredReqL(*msgPtr, rpCause);
+ }
+ else
+ {
+ ret = iLtsyDispatchSmsNackSmsStored->HandleNackSmsStoredReqL(rpCause);
+ }
+
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchNackSmsStoredL
+
+TInt CSmsDispatcher::DispatchAckSmsStoredL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingAckSmsStored
+ * and pass request on to Licensee LTSY.
+ *
+ * @param aDataPackage contains the TPDU defined for a SMS-DELIVER-REPORT
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsAckSmsStored)
+ {
+ TDesC8* msgPtr = NULL;
+ aDataPackage->UnPackData(msgPtr);
+
+ if(msgPtr)
+ {
+ ret = iLtsyDispatchSmsAckSmsStored->HandleAckSmsStoredReqL(*msgPtr);
+ }
+ else
+ {
+ ret = iLtsyDispatchSmsAckSmsStored->HandleAckSmsStoredReqL();
+ }
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchAckSmsStoredL
+
+TInt CSmsDispatcher::DispatchResumeSmsReceptionL()
+/**
+ * @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 (iLtsyDispatchSmsResumeSmsReception)
+ {
+ ret = iLtsyDispatchSmsResumeSmsReception->HandleResumeSmsReceptionReqL();
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchResumeSmsReceptionL
+
+TInt CSmsDispatcher::DispatchSendSmsMessageL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingSendMessage
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsSendSmsMessage)
+ {
+ TSendSmsDataAndAttributes* data = NULL;
+ aDataPackage->UnPackData(&data);
+
+ __ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iAttributes, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iMsgData, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ ret = iLtsyDispatchSmsSendSmsMessage->HandleSendSmsMessageReqL( (data->iAttributes->iDestination),
+ *(data->iMsgData),
+ (data->iAttributes->iDataFormat),
+ (data->iAttributes->iGsmServiceCentre),
+ (data->iAttributes->iMore)
+ );
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchSendSmsMessageL
+
+TInt CSmsDispatcher::DispatchSendSmsMessageNoFdnCheckL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingSendMessageNoFdnCheck
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsSendSmsMessageNoFdnCheck)
+ {
+ TSendSmsDataAndAttributes* data = NULL;
+ aDataPackage->UnPackData(&data);
+
+ __ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iAttributes, CtsyDispatcherPanic(EInvalidNullPtr));
+ __ASSERT_DEBUG(data->iMsgData, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ ret = iLtsyDispatchSmsSendSmsMessageNoFdnCheck->HandleSendSmsMessageNoFdnCheckReqL( (data->iAttributes->iDestination),
+ *(data->iMsgData),
+ (data->iAttributes->iDataFormat),
+ (data->iAttributes->iGsmServiceCentre),
+ (data->iAttributes->iMore)
+ );
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchSendSmsMessageNoFdnCheckL
+
+TInt CSmsDispatcher::DispatchSetMoSmsBearerL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingSetMoSmsBearer
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ // Call Handle... method in Licensee LTSY
+ if (iLtsyDispatchSmsSendSmsMessageNoFdnCheck)
+ {
+ RMobileSmsMessaging::TMobileSmsBearer* data = NULL;
+ aDataPackage->UnPackData(&data);
+ __ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ ret = iLtsyDispatchSmsSetMoSmsBearer->HandleSetMoSmsBearerReqL(*data);
+ }
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchSetMoSmsBearerL
+
+TInt CSmsDispatcher::DispatchStoreSmspListEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileSmsMessagingStoreSmspList
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+ {
+ TSYLOGENTRYEXIT;
+ TInt ret = KErrNotSupported;
+
+ __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ if (iLtsyDispatchSmsStoreSmspListEntry)
+ {
+ RMobileSmsMessaging::TMobileSmspEntryV1* data = NULL;
+ aDataPackage->UnPackData(&data);
+
+ __ASSERT_DEBUG(data, CtsyDispatcherPanic(EInvalidNullPtr));
+
+ ret = iLtsyDispatchSmsStoreSmspListEntry->HandleStoreSmspListEntryReqL(*data);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CSmsDispatcher::DispatchStoreSmspListL
+
+
+//
+// Callback handlers follow
+//
+
+void CSmsDispatcher::CallbackActivateSmsRouting(CRequestQueueOneShot::TIpcDataPackage* aDataPackage)
+/**
+ * Callback function to be used by the request to complete .
+ *
+ * @param aDataPackage Package containing the IPC, return data and result code to be completed to CTSY
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aDataPackage->iResultCode);
+
+ if (!aDataPackage->iCleanupOnly)
+ {
+ CMmDataPackage dataPackage;
+ TUint8 smsRouting = KSmsRoutingActivated;
+ dataPackage.PackData(static_cast<TUint8*>(&smsRouting));
+ iMessageManagerCallback.Complete(EMmTsyActivateSmsRouting, &dataPackage, aDataPackage->iResultCode);
+ }
+ delete aDataPackage;
+ } // CSmsDispatcher::CallbackActivateSmsRouting
+
+
+void CSmsDispatcher::CallbackNotifyReceiveSmsMessage(TInt aError, TBool aInd, const TSmsMsg& aSmsMessage)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsNotifyReceiveSmsMessageInd()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aInd Set routing activity on/off.
+ * @param aSmsMessage Used to buffer incoming SMSes to the TSY.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d, aInd=%d"), aError, aInd);
+
+ TSmsMsg* smsMessagePtr = &const_cast<TSmsMsg&>(aSmsMessage);
+
+ // Pack the data to return to the Common TSY
+ CMmDataPackage dataPackage;
+ dataPackage.PackData(&aInd, &smsMessagePtr);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingReceiveMessage, &dataPackage, aError);
+
+ } // CSmsDispatcher::CallbackNotifyReceiveSmsMessage
+
+void CSmsDispatcher::CallbackSendSatSms(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsSendSatSmsComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ iMessageManagerCallback.Complete(EMmTsySmsSendSatMessage, aError);
+
+ } // CSmsDispatcher::CallbackSendSatSms
+
+void CSmsDispatcher::CallbackGetSmsStoreInfo(TInt aError, TInt aTotalEntries, TInt aUsedEntries)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsGetSmsStoreInfoComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aTotalEntries Indicates the total number of entries that may be held in this store.
+ * @param aUsedEntries Indicates the current number of entries held in this store.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d, aTotalEntries=%d, aUsedEntries=%d"), aError, aTotalEntries, aUsedEntries);
+
+ __ASSERT_DEBUG(aTotalEntries >= 0 && aTotalEntries <= 255, CtsyDispatcherPanic(EBadLength));
+
+ // Pack the data to return to the Common TSY
+ TUint8 tempVar = static_cast<TUint8>(aTotalEntries);
+ CMmDataPackage dataPackage;
+ dataPackage.PackData(&tempVar, &aUsedEntries);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingGetMessageStoreInfo, &dataPackage, aError);
+
+ } // CSmsDispatcher::CallbackGetSmsStoreInfo
+
+void CSmsDispatcher::CallbackGetSmspList(TInt aError, const TDesC& aServiceCenterAddress, const TDesC& aDestinationAddress,
+ const TDesC& aAlphaTagData, const DispatcherSim::TSmsParameters& aSmsParameters, TBool aMoreToCome)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsGetSmspListComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aServiceCenterAddress Service center address.
+ * @param aDestinationAddress Destination address.
+ * @param aAlphaTagData Alpha tag data.
+ * @param aSmsParameters Sms parametets.
+ * @param aMoreToCome Are more elements to come.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d, aMoreToCome=%d"), aError, aMoreToCome);
+
+ if(aError != KErrNone)
+ {
+ __ASSERT_DEBUG(aMoreToCome==EFalse, CtsyDispatcherPanic(EInvalidParameter));
+ }
+
+ //A TRAP new (Eleave) here is expensive, do a non overloaded new operator and check for NULL.
+ TSmsParameters* smsParamsPtr = new TSmsParameters();
+ if (!smsParamsPtr)
+ {
+ // not proceeding
+ __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EInvalidNullPtr));
+ return;
+ }
+ // allocation ok:
+
+ __ASSERT_DEBUG( (aServiceCenterAddress.Length() < KMaxAddressBufferSize) , CtsyDispatcherPanic(EBadLength));
+ smsParamsPtr->iServiceCenterAddress.Copy(aServiceCenterAddress);
+
+ __ASSERT_DEBUG( (aDestinationAddress.Length() < KMaxAddressBufferSize) , CtsyDispatcherPanic(EBadLength));
+ smsParamsPtr->iDestinationAddress.Copy(aDestinationAddress);
+
+ __ASSERT_DEBUG( (aAlphaTagData.Length() < RMobileSmsMessaging::KMaxSmspTextSize) , CtsyDispatcherPanic(EBadLength));
+ smsParamsPtr->iAlphaTagData.Copy(aAlphaTagData);
+
+ smsParamsPtr->iLocationNumber = aSmsParameters.iLocationNumber;
+ smsParamsPtr->iParameterIndicator = aSmsParameters.iParameterIndicator;
+ smsParamsPtr->iProtocolId = aSmsParameters.iProtocolId;
+ smsParamsPtr->iDataCodingScheme = aSmsParameters.iDataCodingScheme;
+ smsParamsPtr->iValidityPeriod = aSmsParameters.iValidityPeriod;
+ smsParamsPtr->iMobileScTON = aSmsParameters.iMobileScTON;
+ smsParamsPtr->iMobileScNPI = aSmsParameters.iMobileScNPI;
+ smsParamsPtr->iMobileDeTON = aSmsParameters.iMobileDeTON;
+ smsParamsPtr->iMobileDeNPI = aSmsParameters.iMobileDeNPI;
+ smsParamsPtr->iAlphaTagPresent = aSmsParameters.iAlphaTagPresent;
+
+ TRAPD(err,iLtsyDataList->AppendL(smsParamsPtr));
+ if(err != KErrNone)
+ {
+ delete smsParamsPtr;
+ smsParamsPtr = NULL;
+ }
+
+ if (!aMoreToCome)
+ {
+ // Pack the data to return to the Common TSY
+ CMmDataPackage dataPackage;
+ dataPackage.PackData(iLtsyDataList);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingGetSmspListPhase1, &dataPackage, aError);
+
+ // handle case, when error on completion:
+ if(aError != KErrNone)
+ {
+ iLtsyDataList->ResetAndDestroy();
+ }
+ else
+ {
+ iLtsyDataList->Reset();
+ }
+ }
+
+ } // CSmsDispatcher::CallbackGetSmspList
+
+void CSmsDispatcher::CallbackNackSmsStored(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsNackSmsStoredComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingNackSmsStored, aError);
+
+ } // CSmsDispatcher::CallbackNackSmsStored
+
+void CSmsDispatcher::CallbackAckSmsStored(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsAckSmsStoredComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingAckSmsStored, aError);
+
+ } // CSmsDispatcher::CallbackAckSmsStored
+
+void CSmsDispatcher::CallbackResumeSmsReception(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsResumeSmsReceptionComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingResumeSmsReception, aError);
+ } // CSmsDispatcher::CallbackResumeSmsReception
+
+void CSmsDispatcher::CallbackSendSmsMessage(TInt aError,
+ TInt aMsgRef, const TDesC8& aSmsSubmitReport)
+/**
+ * Callback function to be used by the request to complete CCtsyDispatcherCallback::CallbackSmsSendSmsMessageComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aMsgRef the message reference assigned to a sent message.
+ * @param aSmsSubmitReport message string, , which is expected to be a buffer with
+ * a maximum size of RMobileSmsMessaging::KGsmTpduSize
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ __ASSERT_DEBUG( (aSmsSubmitReport.Length() < RMobileSmsMessaging::KGsmTpduSize) , CtsyDispatcherPanic(EBadLength));
+
+ // Pack the data to return to the Common TSY
+ CMmDataPackage dataPackage;
+ TPtrC8 submitReport(aSmsSubmitReport);
+
+ dataPackage.PackData(&aMsgRef, &submitReport );
+ iMessageManagerCallback.Complete(EMobileSmsMessagingSendMessage, &dataPackage, aError);
+ } // CSmsDispatcher::CallbackSendSmsMessage
+
+void CSmsDispatcher::CallbackSendSmsMessageNoFdnCheck(TInt aError,
+ TInt aMsgRef, const TDesC8& aSmsSubmitReport)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsSendSmsMessageNoFdnCheckComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aMsgRef the message reference assigned to a sent message.
+ * @param aSmsSubmitReport message string, , which is expected to be a buffer with
+ * a maximum size of RMobileSmsMessaging::KGsmTpduSize
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ __ASSERT_DEBUG( (aSmsSubmitReport.Length() < RMobileSmsMessaging::KGsmTpduSize) , CtsyDispatcherPanic(EBadLength));
+
+ // Pack the data to return to the Common TSY
+ CMmDataPackage dataPackage;
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> submitReport = aSmsSubmitReport;
+
+ dataPackage.PackData(&aMsgRef, &submitReport );
+ iMessageManagerCallback.Complete(EMobileSmsMessagingSendMessageNoFdnCheck, &dataPackage, aError);
+ } // CSmsDispatcher::CallbackSendSmsMessageNoFdnCheck
+
+void CSmsDispatcher::CallbackSetMoSmsBearer(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsSetMoSmsBearerComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ iMessageManagerCallback.Complete(EMobileSmsMessagingSetMoSmsBearer, aError);
+
+ } // CSmsDispatcher::CallbackSetMoSmsBearer
+
+void CSmsDispatcher::CallbackStoreSmspListEntry(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSmsStoreSmspListComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+ iMessageManagerCallback.Complete(EMobileSmsMessagingStoreSmspList, aError);
+ } // CSmsDispatcher::CallbackStoreSmspList
+
+void CSmsDispatcher::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.
+ *
+ * @param aIpcDataPackage Package encapsulating the request.
+ *
+ * @see MDispatcherCallback::CallbackSync
+ */
+ {
+ TSYLOGENTRYEXIT;
+
+ switch (aIpcDataPackage.iIpc)
+ {
+ case EMmTsyActivateSmsRouting:
+ CallbackActivateSmsRouting(&aIpcDataPackage);
+ break;
+ default:
+ LOG(_L8("WARNING: CSmsDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc);
+ __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc));
+ break;
+ } // switch (aIpcDataPackage.iIpc)
+
+ } // CSmsDispatcher::CallbackSync
+
+
+