// 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);