// Copyright (c) 1997-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 "mmtsy.h"

#include "testdef.h"

#include "ETELMM.H"

#include <et_clsvr.h>

#include "Dmmlog.h"

/**************************************************************************/

//

//	CSmsMessagingDMmTsy

//

/**************************************************************************/

CSmsMessagingDMmTsy* CSmsMessagingDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)

	{

	CSmsMessagingDMmTsy* subsession=new(ELeave) CSmsMessagingDMmTsy(aPhone, aFac,aName);

	CleanupStack::PushL(subsession);

	subsession->ConstructL();

	CleanupStack::Pop();

	return subsession;

	}

void CSmsMessagingDMmTsy::Init()

	{}

CSmsMessagingDMmTsy::CSmsMessagingDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)

	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)

	{

	iMessagingName=aName;

	}

void CSmsMessagingDMmTsy::ConstructL()

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy created"));

	iSmspReadAll = new (ELeave) CArrayPtrFlat<CListReadAllAttempt>(1);

	}

CSmsMessagingDMmTsy::~CSmsMessagingDMmTsy()

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy destroyed"));

	if (iSmspReadAll)

		iSmspReadAll->ResetAndDestroy();

	delete iSmspReadAll;

	}

CTelObject* CSmsMessagingDMmTsy::OpenNewObjectByNameL(const TDesC& aName)

	{

	// SMS related stores can be opened from an SMS messaging sub-session

	// Clients must supply the name of the store they wish to open

	if (aName.Compare(KETelMeSmsStore)==KErrNone)

		return REINTERPRET_CAST(CTelObject*, CSmsStoreDMmTsy::NewL(iPhone,FacPtr(),aName));

	if (aName.Compare(KETelIccSmsStore)==KErrNone)

		return REINTERPRET_CAST(CTelObject*, CSmsStoreDMmTsy::NewL(iPhone,FacPtr(),aName));

	return NULL;

	}

CTelObject* CSmsMessagingDMmTsy::OpenNewObjectL(TDes&)

	{

	// Open objects without a name is not supported

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject::TReqMode CSmsMessagingDMmTsy::ReqModeL(const TInt aIpc)

	{

	// ReqModeL is called from the server's CTelObject::ReqAnalyserL

	// in order to check the type of request it has

	// The following are example request types for this dummy TSY

	// All TSYs do not have to have these request types but they have been given

	// "sensible" values in this test code

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

//

// Non-flow Controlled Services

//

	case EMobileSmsMessagingGetCaps:

	case EMobileSmsMessagingGetReceiveMode:

	case EMobileSmsMessagingGetMoSmsBearer:

	case EMobileSmsMessagingEnumerateMessageStores:

	case EMobileSmsMessagingGetMessageStoreInfo:

	case EMobileSmsMessagingResumeSmsReception:

	case EMobileSmsMessagingGetSmspListPhase2:

		break;

//

// Flow Controlled Services

//

	case EMobileSmsMessagingSetReceiveMode:

	case EMobileSmsMessagingSetMoSmsBearer:

	case EMobileSmsMessagingAckSmsStored:

	case EMobileSmsMessagingNackSmsStored:

	case EMobileSmsMessagingSendMessage:

	case EMobileSmsMessagingSendMessageNoFdnCheck:

	case EMobileSmsMessagingGetSmspListPhase1:

	case EMobileSmsMessagingStoreSmspList:

		ret=KReqModeFlowControlObeyed;

		break;

//

//  Immediate server repost of request

//

	case EMobileSmsMessagingReceiveMessage:

		ret=KReqModeRePostImmediately;

		break;

//

// Multiple Completion Services with Immediate Server Repost

// (Usually Notifications)

//

	case EMobileSmsMessagingNotifyReceiveModeChange:

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

	case EMobileSmsMessagingNotifySmspListChange:

		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

//

// Cancel Requests

//	

	case EMobileSmsMessagingSetReceiveModeCancel:

	case EMobileSmsMessagingNotifyReceiveModeChangeCancel:

	case EMobileSmsMessagingNotifyMoSmsBearerChangeCancel:

	case EMobileSmsMessagingAckSmsStoredCancel:

	case EMobileSmsMessagingNackSmsStoredCancel:

	case EMobileSmsMessagingSendMessageCancel:

	case EMobileSmsMessagingSendMessageNoFdnCheckCancel:

	case EMobileSmsMessagingGetMessageStoreInfoCancel:

	case EMobileSmsMessagingGetSmspListCancel:

	case EMobileSmsMessagingStoreSmspListCancel:

	case EMobileSmsMessagingNotifySmspListChangeCancel:

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

TInt CSmsMessagingDMmTsy::RegisterNotification(const TInt aIpc)

	{

	// RegisterNotification is called when the server recognises that this notification

	// is being posted for the first time on this sub-session object.

	// It enables the TSY to "turn on" any regular notification messages that it may 

	// receive from the phone

	switch (aIpc)

		{

	case EMobileSmsMessagingNotifySmspListChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - SMSP List Change"));

		return KErrNone;

	case EMobileSmsMessagingNotifyReceiveModeChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - SMS Receive Mode Change"));

		return KErrNone;

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - SMS Bearer Change"));

		return KErrNone;

	case EMobileSmsMessagingReceiveMessage:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - Receive Message"));

		return KErrNone;

	default:

		// Unknown or invalid IPC

		LOGTEXT(_L8("CSmsMessagingDMmTsy: Register error, unknown IPC"));

		return KErrNotSupported;

		}

	}

TInt CSmsMessagingDMmTsy::DeregisterNotification(const TInt aIpc)

	{

	// DeregisterNotification is called when the server recognises that this notification

	// will not be posted again because the last client to have a handle on this sub-session

	// object has just closed the handle.

	// It enables the TSY to "turn off" any regular notification messages that it may 

	// receive from the phone

	switch (aIpc)

		{

	case EMobileSmsMessagingNotifySmspListChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - SMSP List Change"));

		return KErrNone;

	case EMobileSmsMessagingNotifyReceiveModeChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - SMS Receive Mode Change"));

		return KErrNone;

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - SMS Bearer Change"));

		return KErrNone;

	case EMobileSmsMessagingReceiveMessage:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - Receive Message"));

		return KErrNone;

	default:

		// Unknown or invalid IPC

		LOGTEXT(_L8("CSmsMessagingDMmTsy: Deregister error, unknown IPC"));

		return KErrNotSupported;

		}

	}

TInt CSmsMessagingDMmTsy::NumberOfSlotsL(const TInt aIpc)

	{

	// NumberOfSlotsL is called by the server when it is registering a new notification

	// It enables the TSY to tell the server how many buffer slots to allocate for

	// "repost immediately" notifications that may trigger before clients collect them

	TInt numberOfSlots=1;

	switch (aIpc)

		{

	case EMobileSmsMessagingNotifySmspListChange:

	case EMobileSmsMessagingNotifyReceiveModeChange:

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

	case EMobileSmsMessagingReceiveMessage:

		LOGTEXT(_L8("CSmsMessagingDMmTsy: Registered with 2 slot"));

		numberOfSlots=2;

		break;

	default:

		// Unknown or invalid Phone IPC

		LOGTEXT(_L8("CSmsMessagingDMmTsy: Number of Slots error, unknown IPC"));

		User::Leave(KErrNotSupported);

		break;

		}

	return numberOfSlots;

	}

TInt CSmsMessagingDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

							  const TDataPackage& aPackage)

	{

	// ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request 

	// for the TSY to process

	// A request handle, request type and request data are passed to the TSY

	TAny* dataPtr=aPackage.Ptr1();

	TAny* dataPtr2=aPackage.Ptr2();

	switch (aIpc)

		{

	case EMobileSmsMessagingGetCaps:

		return GetCaps(aTsyReqHandle, aPackage.Des1n());

	case EMobileSmsMessagingEnumerateMessageStores:

		return EnumerateMessageStores(aTsyReqHandle, 

			REINTERPRET_CAST(TInt*, dataPtr));

	case EMobileSmsMessagingGetMessageStoreInfo:

		return GetMessageStoreInfo(aTsyReqHandle, 

			REINTERPRET_CAST(TInt*, dataPtr),

			aPackage.Des2n());

	case EMobileSmsMessagingReceiveMessage:

		return ReceiveMessage(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());

	case EMobileSmsMessagingAckSmsStored:

		return AckSmsStored(aTsyReqHandle, aPackage.Des1n(),

			REINTERPRET_CAST(TBool*, dataPtr2));

	case EMobileSmsMessagingNackSmsStored:

		return NackSmsStored(aTsyReqHandle, aPackage.Des1n(),

			REINTERPRET_CAST(TInt*, dataPtr2));

	case EMobileSmsMessagingResumeSmsReception:

		return ResumeSmsReception(aTsyReqHandle);

	case EMobileSmsMessagingSendMessage:

		return SendMessage(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());

	case EMobileSmsMessagingSendMessageNoFdnCheck:

		return SendMessageNoFdnCheck(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());

	case EMobileSmsMessagingGetSmspListPhase1:

		return ReadSmspListPhase1(aTsyReqHandle,

			REINTERPRET_CAST(RMobilePhone::TClientId*,dataPtr),

			REINTERPRET_CAST(TInt*,dataPtr2));

	case EMobileSmsMessagingGetSmspListPhase2:

		return ReadSmspListPhase2(aTsyReqHandle,

			REINTERPRET_CAST(RMobilePhone::TClientId*,dataPtr), aPackage.Des2n());

	case EMobileSmsMessagingStoreSmspList:

		return StoreSmspList(aTsyReqHandle, aPackage.Des1n());

	case EMobileSmsMessagingNotifySmspListChange:

		return NotifySmspListChange(aTsyReqHandle);

	case EMobileSmsMessagingGetReceiveMode:

		return GetReceiveMode(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsReceiveMode*, dataPtr));

	case EMobileSmsMessagingSetReceiveMode:

		return SetReceiveMode(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsReceiveMode*, dataPtr));

	case EMobileSmsMessagingNotifyReceiveModeChange:

		return NotifyReceiveModeChange(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsReceiveMode*, dataPtr));

	case EMobileSmsMessagingGetMoSmsBearer:

		return GetMoSmsBearer(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsBearer*, dataPtr));

	case EMobileSmsMessagingSetMoSmsBearer:

		return SetMoSmsBearer(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsBearer*, dataPtr));

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

		return NotifyMoSmsBearerChange(aTsyReqHandle,

			REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsBearer*, dataPtr));

	default:

		return KErrNotSupported;

		}

	}

TInt CSmsMessagingDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

	{

	// CancelService is called by the server when it is "cleaning-up" any still outstanding

	// asynchronous requests before closing a client's sub-session.

	// This will happen if a client closes its R-class handle without cancelling outstanding

	// asynchronous requests.

	LOGTEXT(_L8("CSmsMessagingDMmTsy: - CancelService called"));

	switch (aIpc)

		{

	case EMobileSmsMessagingReceiveMessage:

		return ReceiveMessageCancel(aTsyReqHandle);

	case EMobileSmsMessagingAckSmsStored:

		return AckSmsStoredCancel(aTsyReqHandle);

	case EMobileSmsMessagingNackSmsStored:

		return NackSmsStoredCancel(aTsyReqHandle);

	case EMobileSmsMessagingSendMessage:

		return SendMessageCancel(aTsyReqHandle);

	case EMobileSmsMessagingSendMessageNoFdnCheck:

		return SendMessageNoFdnCheckCancel(aTsyReqHandle);

	case EMobileSmsMessagingGetMessageStoreInfo:

		return GetMessageStoreInfoCancel(aTsyReqHandle);

	case EMobileSmsMessagingGetSmspListPhase1:

	case EMobileSmsMessagingGetSmspListPhase2:

		return ReadSmspListCancel(aTsyReqHandle);

	case EMobileSmsMessagingStoreSmspList:

		return StoreSmspListCancel(aTsyReqHandle);

	case EMobileSmsMessagingNotifySmspListChange:

		return NotifySmspListChangeCancel(aTsyReqHandle);

	case EMobileSmsMessagingSetReceiveMode:

		return SetReceiveModeCancel(aTsyReqHandle);

	case EMobileSmsMessagingNotifyReceiveModeChange:

		return NotifyReceiveModeChangeCancel(aTsyReqHandle);

	case EMobileSmsMessagingSetMoSmsBearer:

		return SetMoSmsBearerCancel(aTsyReqHandle);

	case EMobileSmsMessagingNotifyMoSmsBearerChange:

		return NotifyMoSmsBearerChangeCancel(aTsyReqHandle);

	default:

		return KErrGeneral; 

		}

	}

/***********************************************************************************/

//

// The following methods are called from ExtFunc and/or CancelService.

// Each of these will process a TSY request or cancel a TSY request

// Here, example values are returned or checked within this dummy TSY in order to ensure

// that the integrity of the data passed to/from client is maintained

//

/***********************************************************************************/

TInt CSmsMessagingDMmTsy::GetCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetCaps called"));

	RMobileSmsMessaging::TMobileSmsCapsV1Pckg* smsCapsPckg = (RMobileSmsMessaging::TMobileSmsCapsV1Pckg*)aCaps;

	RMobileSmsMessaging::TMobileSmsCapsV1& smsCaps = (*smsCapsPckg)();

	smsCaps.iSmsMode=DMMTSY_SMS_MESSAGING_MODE_CAPS;

	smsCaps.iSmsControl=DMMTSY_SMS_MESSAGING_CONTROL_CAPS;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::ReceiveMessage(const TTsyReqHandle aTsyReqHandle, TDes8* aMsg, TDes8* aMsgAttributes)

	{

	if (!iReceiveMessage++)

		{

		LOGTEXT(_L8("CSmsMessagingDMmTsy::ReceiveMessage called"));

		RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg*, aMsgAttributes);

		RMobileSmsMessaging::TMobileSmsReceiveAttributesV1& atts = (*attsPckg)();

		atts.iFlags=DMMTSY_SMS_MESSAGE_FLAGS1;

		atts.iDataFormat=DMMTSY_SMS_MESSAGE_FORMAT1;

		atts.iGsmServiceCentre.iTelNumber=DMMTSY_SMS_MESSAGE_SC1;

		atts.iOriginator.iTelNumber=DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER1;

		atts.iStatus=DMMTSY_SMS_MESSAGE_STATUS1;

		atts.iStore=DMMTSY_MESSAGE_STORE_NAME;

		atts.iStoreIndex=DMMTSY_SMS_STORE_INDEX1;

		aMsg->Copy(DMMTSY_SMS_MESSAGE_PDU1);

		iPhone->AddDelayedReq(aTsyReqHandle,this);

		}

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::ReceiveMessageCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReceiveMessageCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::AckSmsStored(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsg, TBool* aFull)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::AckSmsStored called"));

	if (((aMsg->Length()!=0) && (aMsg->Compare(DMMTSY_SMS_MESSAGE_PDU1)!=0)) || 

		(*aFull != DMMTSY_SMS_MESSAGE_FULL))

		ReqCompleted(aTsyReqHandle,KErrCorrupt);

	else

		iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::AckSmsStoredCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::AckSmsStoredCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::NackSmsStored(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsgData, TInt* aRpCause)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::NackSmsStored called"));

	if ((aMsgData->Compare(DMMTSY_SMS_MESSAGE_PDU1) != 0 ) || *aRpCause != DMMTSY_SMS_MESSAGE_NACK_CAUSE)

		ReqCompleted(aTsyReqHandle,KErrCorrupt);

	else

		iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::NackSmsStoredCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::NackSmsStoredCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::ResumeSmsReception(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::ResumeSmsReception called"));

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CSmsMessagingDMmTsy::SendMessage(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsg, TDes8* aMsgAttributes)

	{

	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessage called"));

	RMobileSmsMessaging::TMobileSmsAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsAttributesV1Pckg*, aMsgAttributes);

	RMobileSmsMessaging::TMobileSmsAttributesV1& atts = (*attsPckg)();

	if (atts.ExtensionId() == RMobileSmsMessaging::KETelMobileSmsSendAttributesV1)

		{

		RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg* attsV1Pckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg*, aMsgAttributes);

		RMobileSmsMessaging::TMobileSmsSendAttributesV1& attsV1 = (*attsV1Pckg)();

		if ((attsV1.iFlags != DMMTSY_SMS_MESSAGE_FLAGS2) ||

			(attsV1.iDataFormat != DMMTSY_SMS_MESSAGE_FORMAT1) ||

			(attsV1.iDestination.iTelNumber != DMMTSY_PHONE_TEL_NUMBER) ||

			(attsV1.iMore != DMMTSY_SMS_MESSAGE_MORE) ||

			(aMsg->Compare(DMMTSY_SMS_MESSAGE_PDU1) != 0))

			{

			ReqCompleted(aTsyReqHandle, KErrCorrupt);

			}

		else

			{

			attsV1.iMsgRef = DMMTSY_SMS_MESSAGE_MSGREF;

			attsV1.iSubmitReport = DMMTSY_SMS_MESSAGE_PDU2;

			iPhone->AddDelayedReq(aTsyReqHandle, this);

			}

		}

	else if (atts.ExtensionId() == RMobileSmsMessaging::KETelMobileSmsCdmaSendAttributesV4)

		{

		RMobileSmsMessaging::TMobileSmsCdmaSendAttributesV4Pckg* attsV4Pckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsCdmaSendAttributesV4Pckg*, aMsgAttributes);

		RMobileSmsMessaging::TMobileSmsCdmaSendAttributesV4& attsV4 = (*attsV4Pckg)();

		if ((attsV4.iFlags != DMMTSY_SMS_MESSAGE_CDMA_FLAGS) ||

			(attsV4.iDataFormat != DMMTSY_SMS_MESSAGE_CDMA_FORMAT) ||

			(attsV4.iCdmaTeleservice != DMMTSY_SMS_MESSAGE_CDMA_TELESERVICE) ||

			(attsV4.iCdmaServiceCategory != DMMTSY_SMS_MESSAGE_CDMA_SERVICE_CATEGORY) ||

			(attsV4.iMore != DMMTSY_SMS_MESSAGE_MORE) ||

			(attsV4.iDestination.iTypeOfNumber != DMMTSY_SMS_MESSAGE_TON) ||

			(attsV4.iDestination.iNumberPlan != DMMTSY_SMS_MESSAGE_NP) ||

			(attsV4.iDestination.iTelNumber != DMMTSY_PHONE_TEL_NUMBER) ||

			(attsV4.iAddressAuthentication != DMMTSY_SMS_MESSAGE_ADDRESS_AUTHENTICATION) ||

			(aMsg->Compare(DMMTSY_SMS_MESSAGE_PDU1) != 0))

			{

			ReqCompleted(aTsyReqHandle, KErrCorrupt);

			}

		else

			{

			attsV4.iMsgRef = DMMTSY_SMS_MESSAGE_MSGREF;

			attsV4.iTLAck = DMMTSY_SMS_MESSAGE_TLACK;

			iPhone->AddDelayedReq(aTsyReqHandle, this);

			}

		}

	else

		{

		ReqCompleted(aTsyReqHandle, KErrCorrupt);

		}