--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelmultimode/DTsy/mmtsymessaging.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1914 @@
+// 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);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SendMessageCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SendMessageNoFdnCheck(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsg, TDes8* aMsgAttributes)
+	/**
+	* This method sends an outgoing SMS to the network. The number used for sending the SMS   
+	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+	*
+	* @param aMsg Supplies the TPDU to send
+	* @param aMsgAttributes Supplies the attributes of the outgoing message
+	*/
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageNoFdnCheck called"));
+	
+	RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg*, aMsgAttributes);
+	RMobileSmsMessaging::TMobileSmsSendAttributesV1& atts = (*attsPckg)();
+
+	if ((atts.iFlags != DMMTSY_SMS_MESSAGE_FLAGS2) ||
+		(atts.iDataFormat != DMMTSY_SMS_MESSAGE_FORMAT1) ||
+		(atts.iDestination.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) != 0) ||
+		(atts.iMore != DMMTSY_SMS_MESSAGE_MORE) ||
+		(aMsg->Compare(DMMTSY_SMS_MESSAGE_PDU1) != 0))
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		{
+		atts.iMsgRef=DMMTSY_SMS_MESSAGE_MSGREF;
+		atts.iSubmitReport=DMMTSY_SMS_MESSAGE_PDU2;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SendMessageNoFdnCheckCancel(const TTsyReqHandle aTsyReqHandle)
+	/**
+	* This method cancels the sending of an outgoing SMS to the network. The number used for sending the SMS   
+	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+	*
+	*/
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageNoFdnCheckCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::EnumerateMessageStores(const TTsyReqHandle aTsyReqHandle, TInt* aCount)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::EnumerateMessageStores called"));
+	*aCount=DMMTSY_PHONE_MESSAGE_STORE_COUNT;
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::GetMessageStoreInfo(const TTsyReqHandle aTsyReqHandle, TInt *aIndex, TDes8* aInfo)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMessageStoreInfo called"));
+	
+	if (*aIndex != DMMTSY_SMS_STORE_INDEX1)
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		{
+		RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg* infoPckg = REINTERPRET_CAST(RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*, aInfo);
+		RMobilePhoneStore::TMobilePhoneStoreInfoV1& info = (*infoPckg)();
+
+		info.iName=DMMTSY_MESSAGE_STORE_NAME;
+		info.iType=DMMTSY_MESSAGE_STORE_TYPE;
+		info.iTotalEntries=DMMTSY_MESSAGE_STORE_TOTAL_ENTRIES;
+		info.iUsedEntries=DMMTSY_MESSAGE_STORE_USED_ENTRIES;
+		info.iCaps=DMMTSY_MESSAGE_STORE_CAPS;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::GetMessageStoreInfoCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMessageStoreInfoCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::ValidateSmspEntry(const RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)
+	{
+	if ((aEntry.iText != DMMTSY_SMSP_STORE_TEXT1) ||
+		(aEntry.iValidParams != DMMTSY_SMSP_STORE_VALID_PARAMS1) ||
+		(aEntry.iDestination.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) != 0) ||
+		(aEntry.iValidityPeriod != DMMTSY_SMSP_STORE_VALIDITY1) ||
+		(aEntry.iServiceCentre.iTelNumber.Compare(DMMTSY_SMSP_STORE_SCA) != 0) ||
+		(aEntry.iProtocolId != DMMTSY_SMSP_STORE_PID1) ||
+		(aEntry.iDcs != DMMTSY_SMSP_STORE_DCS1))
+		return KErrCorrupt;
+	else
+		return KErrNone;
+	}
+
+void CSmsMessagingDMmTsy::InitSmspEntry(RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)
+	{
+	aEntry.iText = DMMTSY_SMSP_STORE_TEXT1;
+	aEntry.iValidParams = DMMTSY_SMSP_STORE_VALID_PARAMS1;
+	aEntry.iDestination.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;
+	aEntry.iValidityPeriod = DMMTSY_SMSP_STORE_VALIDITY1;
+	aEntry.iServiceCentre.iTelNumber = DMMTSY_SMSP_STORE_SCA;
+	aEntry.iProtocolId = DMMTSY_SMSP_STORE_PID1;
+	aEntry.iDcs = DMMTSY_SMSP_STORE_DCS1;
+	}
+
+
+TInt CSmsMessagingDMmTsy::ReadSmspListPhase1(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aId, TInt* aBufSize)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListPhase1 called"));
+	TInt ret=KErrNone;
+	TInt leaveCode=KErrNone;
+	TRAP(leaveCode, ret=ProcessReadSmspListPhase1L(aTsyReqHandle, aId, aBufSize););
+	if (leaveCode != KErrNone)
+		ReqCompleted(aTsyReqHandle,leaveCode);
+	return ret;
+	};
+
+TInt CSmsMessagingDMmTsy::ProcessReadSmspListPhase1L(const TTsyReqHandle aTsyReqHandle, 
+											 RMobilePhone::TClientId* aId, 
+											 TInt* aBufSize)
+	{
+	// read the list, store its content and then return size of this buffer to client
+	CMobilePhoneSmspList* list=CMobilePhoneSmspList::NewL();
+	CleanupStack::PushL(list);
+
+	RMobileSmsMessaging::TMobileSmspEntryV1 entry;
+
+	// fill up an example list
+	for (TInt index=0; index < DMMTSY_SMSP_STORE_COUNT; index++)
+		{
+		switch (index)
+			{
+		case 0:
+			InitSmspEntry(entry);
+
+			entry.iIndex=DMMTSY_SMSP_STORE_INDEX1;
+			break;
+		case 1:
+			InitSmspEntry(entry);
+
+			entry.iIndex=DMMTSY_SMSP_STORE_INDEX2;
+		default:
+			break;
+			}
+			// Add the entry into the list, at the next empty location
+			list->AddEntryL(entry);
+		}
+
+	// Store the streamed list and the client ID
+	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aId,aTsyReqHandle);
+	CleanupStack::PushL(read);
+	
+	read->iListBuf = list->StoreLC();
+	CleanupStack::Pop(); // pop the CBufFlat allocated by StoreLC
+	
+	iSmspReadAll->AppendL(read);
+	CleanupStack::Pop(); // pop the CListReadAllAttempt
+	
+	// return the CBufFlat’s size to client
+	*aBufSize=(read->iListBuf)->Size();
+	
+	// Complete first phase of list retrieval
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+	CleanupStack::PopAndDestroy(); // pop&destroy list
+	return KErrNone;
+	}
+
+
+TInt CSmsMessagingDMmTsy::ReadSmspListPhase2(TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aId, TDes8* aBuffer)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListPhase2 called"));
+	CListReadAllAttempt* read=NULL;
+	// Find the read attempt from this client
+	for (TInt i=0; i<iSmspReadAll->Count(); ++i)
+		{
+		read = iSmspReadAll->At(i);
+		if ((read->iClient.iSessionHandle==aId->iSessionHandle) &&
+		    (read->iClient.iSubSessionHandle==aId->iSubSessionHandle))
+			{
+			TPtr8 bufPtr((read->iListBuf)->Ptr(0));
+			// Copy the streamed list to the client
+			aBuffer->Copy(bufPtr);
+			delete read;
+			iSmspReadAll->Delete(i);
+			ReqCompleted(aTsyReqHandle,KErrNone);
+			return KErrNone;
+			}
+		}
+	// Should handle error case of not finding the matching client from read all phase 1
+	return KErrNotFound;
+	}
+
+
+TInt CSmsMessagingDMmTsy::ReadSmspListCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	
+	// Remove the read all attempt from iSmspReadAll
+	CListReadAllAttempt* read=NULL;
+	for (TInt i=0; i<iSmspReadAll->Count(); ++i)
+		{
+		read = iSmspReadAll->At(i);
+		if (read->iReqHandle == aTsyReqHandle)
+			{
+			delete read;
+			iSmspReadAll->Delete(i);
+			break;
+			}
+		}
+
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::StoreSmspList(const TTsyReqHandle aTsyReqHandle, TDes8* aBuffer)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::StoreSmspList called"));
+	TInt ret=KErrNone;
+	TInt leaveCode=KErrNone;
+	TRAP(leaveCode, ret=ProcessStoreSmspListL(aTsyReqHandle, aBuffer););
+	if (leaveCode != KErrNone)
+		ReqCompleted(aTsyReqHandle,leaveCode);
+	return ret;
+	};
+
+TInt CSmsMessagingDMmTsy::ProcessStoreSmspListL(TTsyReqHandle aTsyReqHandle, TDes8* aBuffer)
+	{
+	CMobilePhoneSmspList* aSmspList=CMobilePhoneSmspList::NewL();
+	CleanupStack::PushL(aSmspList);
+	
+	aSmspList->RestoreL(*aBuffer);
+
+	RMobileSmsMessaging::TMobileSmspEntryV1 entry;
+
+	if (aSmspList->Enumerate() != DMMTSY_SMSP_STORE_COUNT)
+		{
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+		return KErrNone;
+		}
+
+	entry=aSmspList->GetEntryL(0);
+
+	if ((entry.iIndex != DMMTSY_SMSP_STORE_INDEX1) ||  
+		(ValidateSmspEntry(entry) != KErrNone))
+		{
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+		return KErrNone;
+		}
+
+	entry=aSmspList->GetEntryL(1);
+
+	if ((entry.iIndex != DMMTSY_SMSP_STORE_INDEX2) ||  
+		(ValidateSmspEntry(entry) != KErrNone))
+		{
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+		return KErrNone;
+		}
+
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+	CleanupStack::PopAndDestroy(); // aSmspList
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::StoreSmspListCancel(TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmspStoreDMmTsy::StoreSmspListCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifySmspListChange(const TTsyReqHandle aTsyReqHandle)
+	{
+	if (!iNotifySmspListChange++)
+		{
+		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifySmspListChange called"));
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifySmspListChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifySmspListChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;	
+	}
+
+
+TInt CSmsMessagingDMmTsy::GetReceiveMode(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetReceiveMode called"));
+	*aReceiveMode=DMMTSY_SMS_MESSAGING_RECEIVE_MODE1;
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SetReceiveMode(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetReceiveMode called"));
+	if ( *aReceiveMode != DMMTSY_SMS_MESSAGING_RECEIVE_MODE1 )
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		{
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SetReceiveModeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetReceiveModeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifyReceiveModeChange(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)
+	{
+	if (!iNotifyReceiveModeChange++)
+		{
+		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyReceiveModeChange called"));
+		*aReceiveMode=DMMTSY_SMS_MESSAGING_RECEIVE_MODE2;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifyReceiveModeChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyReceiveModeChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::GetMoSmsBearer(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMoSmsBearer called"));
+	*aBearer=DMMTSY_SMS_MESSAGING_BEARER1;
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SetMoSmsBearer(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetMoSmsBearer called"));
+	if ( *aBearer != DMMTSY_SMS_MESSAGING_BEARER1 )
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		{
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::SetMoSmsBearerCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetMoSmsBearerCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifyMoSmsBearerChange(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)
+	{
+	if (!iNotifyMoSmsBearerChange++)
+		{
+		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyMoSmsBearerChange called"));
+		*aBearer=DMMTSY_SMS_MESSAGING_BEARER2;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CSmsMessagingDMmTsy::NotifyMoSmsBearerChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyMoSmsBearerChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+/**************************************************************************/
+//
+//	CBroadcastMessagingDMmTsy
+//
+/**************************************************************************/
+
+CBroadcastMessagingDMmTsy* CBroadcastMessagingDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)
+	{
+	CBroadcastMessagingDMmTsy* subsession=new(ELeave) CBroadcastMessagingDMmTsy(aPhone,aFac,aName);
+	CleanupStack::PushL(subsession);
+	subsession->ConstructL();
+	CleanupStack::Pop();
+	return subsession;
+	}
+
+void CBroadcastMessagingDMmTsy::Init()
+	{}
+
+CBroadcastMessagingDMmTsy::CBroadcastMessagingDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)
+	:CSubSessionExtDummyBase(aFac), iPhone(aPhone), iCbmiListRequests(NULL)
+	{
+	iMessagingName=aName;
+	}
+
+void CBroadcastMessagingDMmTsy::ConstructL()
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy created"));
+	iCbmiListRequests = new (ELeave) CArrayPtrFlat<CListReadAllAttempt>(16);
+	}
+
+CBroadcastMessagingDMmTsy::~CBroadcastMessagingDMmTsy()
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy destroyed"));
+	iCbmiListRequests->ResetAndDestroy();
+	delete iCbmiListRequests;
+	}
+
+CTelObject* CBroadcastMessagingDMmTsy::OpenNewObjectByNameL(const TDesC& /*aName*/)
+	{
+	// Broadcast related stores can be opened from a Broadcast messaging sub-session
+
+
+	return NULL;
+	}
+
+CTelObject* CBroadcastMessagingDMmTsy::OpenNewObjectL(TDes&)
+	{
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CTelObject::TReqMode CBroadcastMessagingDMmTsy::ReqModeL(const TInt aIpc)
+	{
+	CTelObject::TReqMode ret=0;
+	switch (aIpc)
+		{
+//
+// Non-Flow Controlled Services
+//
+	case EMobileBroadcastMessagingGetFilterSetting:
+	case EMobileBroadcastMessagingGetCaps:
+	case EMobileBroadcastMessagingGetLanguageFilter:
+	case EMobileBroadcastMessagingSetLanguageFilter:
+	case EMobileBroadcastMessagingGetIdListPhase1:
+	case EMobileBroadcastMessagingGetIdListPhase2:
+	case EMobileBroadcastMessagingStoreIdList:
+		break;
+
+//
+// Flow Controlled Services
+//
+	case EMobileBroadcastMessagingSetFilterSetting:
+		ret=KReqModeFlowControlObeyed;
+		break;
+
+//
+// Multiple Completion Services with Immediate Server Repost
+// (Usually Notifications)
+//
+	case EMobileBroadcastMessagingReceiveMessage:
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
+		break;
+//
+// Cancel Requests
+//	
+	case EMobileBroadcastMessagingReceiveMessageCancel:
+	case EMobileBroadcastMessagingNotifyFilterSettingChangeCancel:
+	case EMobileBroadcastMessagingSetFilterSettingCancel:
+	case EMobileBroadcastMessagingGetLanguageFilterCancel:
+	case EMobileBroadcastMessagingSetLanguageFilterCancel:
+	case EMobileBroadcastMessagingNotifyLanguageFilterChangeCancel:
+	case EMobileBroadcastMessagingGetIdListCancel:
+	case EMobileBroadcastMessagingStoreIdListCancel:
+	case EMobileBroadcastMessagingNotifyIdListChangeCancel:
+	default:
+		User::Leave(KErrNotSupported);
+		break;
+		}
+
+	return ret;
+	}
+
+TInt CBroadcastMessagingDMmTsy::RegisterNotification(const TInt aIpc)
+	{
+	switch (aIpc)
+		{
+	case EMobileBroadcastMessagingReceiveMessage:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Receive Message"));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Receive setting Change "));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Language Filter Change "));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - Notify BroadcastId List Change"));
+		return KErrNone;
+	default:
+		// Unknown or invalid IPC
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Register error, unknown IPC"));
+		return KErrNotSupported;
+		}
+	}
+
+TInt CBroadcastMessagingDMmTsy::DeregisterNotification(const TInt aIpc)
+	{
+	switch (aIpc)
+		{
+	case EMobileBroadcastMessagingReceiveMessage:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Receive Message"));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Receive setting Change "));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Language Filter Change "));
+		return KErrNone;
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - Notify BroadcastId List Change"));
+		return KErrNone;
+	default:
+		// Unknown or invalid IPC
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Deregister error, unknown IPC"));
+		return KErrNotSupported;
+		}
+	}
+
+TInt CBroadcastMessagingDMmTsy::NumberOfSlotsL(const TInt aIpc)
+	{
+	TInt numberOfSlots=1;
+	switch (aIpc)
+		{
+	case EMobileBroadcastMessagingReceiveMessage:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Registered with 10 slots"));
+		numberOfSlots=10;
+		break;
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Registered with 2 slots"));
+		numberOfSlots=2;
+		break;
+	default:
+		// Unknown or invalid Phone IPC
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Number of Slots error, unknown IPC"));
+		User::Leave(KErrNotSupported);
+		break;
+		}
+	return numberOfSlots;
+	}
+
+
+TInt CBroadcastMessagingDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,
+							  const TDataPackage& aPackage)
+	{
+	TInt err;
+	TAny* dataPtr=aPackage.Ptr1();
+	TAny* dataPtr2=aPackage.Ptr2();
+
+	switch (aIpc)
+		{
+	case EMobileBroadcastMessagingGetCaps:
+		return GetCaps(aTsyReqHandle, aPackage.Des1n());
+
+	case EMobileBroadcastMessagingGetFilterSetting:
+		return GetFilterSetting(aTsyReqHandle,
+			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));
+	
+	case EMobileBroadcastMessagingSetFilterSetting:
+		return SetFilterSetting(aTsyReqHandle,
+			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));
+
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+		return NotifyFilterSettingChange(aTsyReqHandle,
+			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));
+	
+	case EMobileBroadcastMessagingReceiveMessage:
+		return ReceiveMessage(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());
+	
+	case EMobileBroadcastMessagingGetLanguageFilter:
+		return GetLanguageFilter(aTsyReqHandle, aPackage.Des1u());
+
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+		return NotifyLanguageFilterChange(aTsyReqHandle, aPackage.Des1u());
+
+	case EMobileBroadcastMessagingSetLanguageFilter:
+		return SetLanguageFilter(aTsyReqHandle, aPackage.Des1u());
+	
+	case EMobileBroadcastMessagingReceiveMessageCancel:
+		return ReceiveMessageCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingNotifyFilterSettingChangeCancel:
+		return NotifyFilterSettingChangeCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingSetFilterSettingCancel:
+		return SetFilterSettingCancel(aTsyReqHandle);
+
+	case EMobileBroadcastMessagingGetIdListPhase1:
+		return GetBroadcastIdListPhase1(aTsyReqHandle,
+			REINTERPRET_CAST(CRetrieveMobilePhoneBroadcastIdList::TGetBroadcastIdRequest*, dataPtr),
+			REINTERPRET_CAST(TInt*, dataPtr2));
+	case EMobileBroadcastMessagingGetIdListPhase2:
+		return GetBroadcastIdListPhase2(aTsyReqHandle,
+			REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr),
+			aPackage.Des2n());
+	case EMobileBroadcastMessagingStoreIdList:
+		{
+		TRAP(err,StoreBroadcastIdListL(aTsyReqHandle,aPackage.Des1n()));
+		if (err != KErrNone)
+			ReqCompleted(aTsyReqHandle,err);
+		return KErrNone;
+		}
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		return NotifyBroadcastIdListChange(aTsyReqHandle);
+	default:
+		return KErrNotSupported;
+		}
+	}
+
+TInt CBroadcastMessagingDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy: - CancelService called"));
+	switch (aIpc)
+		{
+	case EMobileBroadcastMessagingReceiveMessage:
+		return ReceiveMessageCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingNotifyFilterSettingChange:
+		return NotifyFilterSettingChangeCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingSetFilterSetting:
+		return SetFilterSettingCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingGetLanguageFilter:
+		return GetLanguageFilterCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingSetLanguageFilter:
+		return SetLanguageFilterCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingNotifyLanguageFilterChange:
+		return NotifyLanguageFilterChangeCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingGetIdListPhase1:
+	case EMobileBroadcastMessagingGetIdListPhase2:
+		return GetBroadcastIdListCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingStoreIdList:
+		return StoreBroadcastIdListCancel(aTsyReqHandle);
+	case EMobileBroadcastMessagingNotifyIdListChange:
+		return NotifyBroadcastIdListChangeCancel(aTsyReqHandle);
+	default:
+		return KErrGeneral; 
+		}
+	}
+
+
+TInt CBroadcastMessagingDMmTsy::GetCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetCaps called"));
+	RMobileBroadcastMessaging::TMobileBroadcastCapsV1Pckg* cbsCapsPckg = (RMobileBroadcastMessaging::TMobileBroadcastCapsV1Pckg*)aCaps;
+	RMobileBroadcastMessaging::TMobileBroadcastCapsV1& cbsCaps = (*cbsCapsPckg)();
+
+	cbsCaps.iModeCaps=DMMTSY_BROADCAST_MESSAGING_MODE_CAPS;
+	cbsCaps.iFilterCaps=DMMTSY_BROADCAST_MESSAGING_FILTER_CAPS;
+
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::ReceiveMessage(const TTsyReqHandle aTsyReqHandle, TDes8* aMsgData, TDes8* aMsgAtts)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::ReceiveMessage called"));
+
+	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileBroadcastMessaging::TMobileBroadcastAttributesV1Pckg*, aMsgAtts);
+	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1 &atts = (*attsPckg)();
+	
+	if(atts.ExtensionId()==KETelExtMultimodeV2)
+		{
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy::ReceiveMessage is using V2 attributes"));
+
+		RMobileBroadcastMessaging::TMobileBroadcastAttributesV2Pckg* attsV2Pckg = REINTERPRET_CAST(RMobileBroadcastMessaging::TMobileBroadcastAttributesV2Pckg*, aMsgAtts);
+		RMobileBroadcastMessaging::TMobileBroadcastAttributesV2 &attsV2 = (*attsV2Pckg)();
+
+		attsV2.iFormat = DMMTSY_CBS_MESSAGE_PDU_FORMAT;
+		attsV2.iFlags = DMMTSY_BROADCAST_MESSAGING_ATT_FLAGS;
+		attsV2.iDCS = DMMTSY_BROADCAST_MESSAGING_ATT_DCS;
+		attsV2.iMessageId = DMMTSY_BROADCAST_MESSAGING_ATT_MSGID;
+		attsV2.iMessageType =DMMTSY_BROADCAST_MESSAGING_ATT_MSGTYPE;
+		attsV2.iNumberOfPages = DMMTSY_BROADCAST_MESSAGING_ATT_NUMOFPAGES;
+		attsV2.iSerialNum = DMMTSY_BROADCAST_MESSAGING_ATT_SERIAL;
+
+		*aMsgData = DMMTSY_CBS_MESSAGE_PDU;
+		}
+	else if(atts.ExtensionId()==KETelExtMultimodeV1)
+		{
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy::ReceiveMessage is using V1 attributes"));
+
+		atts.iFormat = DMMTSY_CBS_MESSAGE_PDU_FORMAT;
+		atts.iFlags = DMMTSY_BROADCAST_MESSAGING_ATT_FLAGS;
+		*aMsgData = DMMTSY_CBS_MESSAGE_PDU;
+		}
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::ReceiveMessageCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::ReceiveMessageCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetFilterSetting(const TTsyReqHandle aTsyReqHandle, RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter* aSetting)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetFilterSetting called"));
+	*aSetting=DMMTSY_BROADCAST_RECEIVE_SETTING1;
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::SetFilterSetting(const TTsyReqHandle aTsyReqHandle, RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter* aSetting)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::SetFilterSetting called"));
+	if ( *aSetting != DMMTSY_BROADCAST_RECEIVE_SETTING2 )
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		{
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::SetFilterSettingCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::SetFilterSettingCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyFilterSettingChange(const TTsyReqHandle aTsyReqHandle, RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter* aSetting)
+	{
+	if (!iNotifyFilterSettingChange++)
+		{
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyFilterSettingChange called"));
+		*aSetting=DMMTSY_BROADCAST_RECEIVE_SETTING2;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyFilterSettingChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyFilterSettingChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetLanguageFilter(const TTsyReqHandle aTsyReqHandle, TDes16* aLangFilter)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetLanguageFilter called"));
+	*aLangFilter = DMMTSY_CBS_MESSAGE_LANGUAGE_FILTER;
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetLanguageFilterCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetLanguageFilterCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::SetLanguageFilter(const TTsyReqHandle aTsyReqHandle, TDesC16* aLangFilter)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::SetLanguageFilter called"));
+	if (aLangFilter->Compare(DMMTSY_CBS_MESSAGE_LANGUAGE_FILTER) != 0)
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::SetLanguageFilterCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::SetLanguageFilterCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyLanguageFilterChange(const TTsyReqHandle aTsyReqHandle, TDes16* aLangFilter)
+	{
+	if (!iNotifyLanguageFilterChange++)
+		{
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyLanguageFilterChange called"));
+		*aLangFilter = DMMTSY_CBS_MESSAGE_LANGUAGE_FILTER;
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyLanguageFilterChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyLanguageFilterChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetBroadcastIdListPhase1(const TTsyReqHandle aTsyReqHandle, CRetrieveMobilePhoneBroadcastIdList::TGetBroadcastIdRequest* aReqData, TInt* aBufSize)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetBroadcastIdListPhase1 called"));
+	TInt ret=KErrNone;
+	TInt leaveCode=KErrNone;
+
+	if (aReqData->iIdType != DMMTSY_BROADCAST_ID_TYPE)
+		leaveCode = KErrCorrupt;
+
+	if (!leaveCode)
+		TRAP(leaveCode, ret=ProcessGetBroadcastIdListPhase1L(aTsyReqHandle, &aReqData->iClient, aBufSize););
+
+	if (leaveCode != KErrNone)
+		ReqCompleted(aTsyReqHandle,leaveCode);
+	return ret;
+	}
+
+TInt CBroadcastMessagingDMmTsy::ProcessGetBroadcastIdListPhase1L(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aClient, TInt* aBufSize)
+	{
+	CMobilePhoneBroadcastIdList* list=CMobilePhoneBroadcastIdList::NewL();
+	CleanupStack::PushL(list);
+
+	RMobileBroadcastMessaging::TMobileBroadcastIdEntryV1 entry;
+
+	// fill up an example list
+	for (TInt index=0; index < DMMTSY_CBMI_STORE_COUNT; index++)
+		{
+		switch (index)
+			{
+		case 0:
+			entry.iId=DMMTSY_CBMI_ID1;
+			break;
+		case 1:
+			entry.iId=DMMTSY_CBMI_ID2;
+			break;
+		case 2:
+			entry.iId=DMMTSY_CBMI_ID3;
+			break;
+			}
+			// Add the entry into the list, at the next empty location
+			list->AddEntryL(entry);
+		}
+
+	list->SetMaxNumberEntries(DMMTSY_CBMI_MAX_ENTRIES);
+
+	// Store the streamed list and the client ID
+	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aClient,aTsyReqHandle);
+	CleanupStack::PushL(read);
+	
+	read->iListBuf = list->StoreLC();
+	CleanupStack::Pop(); // pop the CBufFlat allocated by StoreLC
+	
+	iCbmiListRequests->AppendL(read);
+	CleanupStack::Pop(); // pop the CListReadAllAttempt
+	
+	// return the CBufFlat’s size to client
+	*aBufSize=(read->iListBuf)->Size();
+	
+	// Complete first phase of list retrieval
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+	CleanupStack::PopAndDestroy(); // pop&destroy list
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetBroadcastIdListPhase2(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aClient, TDes8* aBuf)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetBroadcastIdListPhase2 called"));
+	CListReadAllAttempt* read=NULL;
+	// Find the read attempt from this client
+	for (TInt i=0; i<iCbmiListRequests->Count(); ++i)
+		{
+		read = iCbmiListRequests->At(i);
+		if ((read->iClient.iSessionHandle==aClient->iSessionHandle) &&
+		    (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle))
+			{
+			TPtr8 bufPtr((read->iListBuf)->Ptr(0));
+			// Copy the streamed list to the client
+			aBuf->Copy(bufPtr);
+			delete read;
+			iCbmiListRequests->Delete(i);
+			ReqCompleted(aTsyReqHandle,KErrNone);
+			return KErrNone;
+			}
+		}
+
+	return KErrNotFound;
+	}
+
+TInt CBroadcastMessagingDMmTsy::GetBroadcastIdListCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::GetBroadcastIdListCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+
+	// Remove the read all attempt from iCbmiListRequests
+	CListReadAllAttempt* read=NULL;
+	for (TInt i=0; i<iCbmiListRequests->Count(); ++i)
+		{
+		read = iCbmiListRequests->At(i);
+		if (read->iReqHandle == aTsyReqHandle)
+			{
+			delete read;
+			iCbmiListRequests->Delete(i);
+			break;
+			}
+		}
+
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+void CBroadcastMessagingDMmTsy::StoreBroadcastIdListL(const TTsyReqHandle aTsyReqHandle, TDes8* aList)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::StoreBroadcastIdListL called"));
+	
+	TInt i;
+	CMobilePhoneBroadcastIdList* list=CMobilePhoneBroadcastIdList::NewL();
+	CleanupStack::PushL(list);
+	list->RestoreL(*aList);
+	if (list->Enumerate() != DMMTSY_CBMI_STORE_COUNT)
+		User::Leave(KErrCorrupt);
+
+	for (i = 0; i < list->Enumerate() && list->GetEntryL(i).iId == DMMTSY_CBMI_ID1; i++)
+		{
+		}
+	if (i != list->Enumerate())
+		User::Leave(KErrCorrupt);
+
+	iPhone->AddDelayedReq(aTsyReqHandle,this);
+
+	CleanupStack::PopAndDestroy(); // list
+	}
+
+TInt CBroadcastMessagingDMmTsy::StoreBroadcastIdListCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::StoreBroadcastIdListCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyBroadcastIdListChange(const TTsyReqHandle aTsyReqHandle)
+	{
+	if (!iNotifyBroadcastIdListChange++)
+		{
+		LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyBroadcastIdListChange called"));
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CBroadcastMessagingDMmTsy::NotifyBroadcastIdListChangeCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CBroadcastMessagingDMmTsy::NotifyBroadcastIdListChangeCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;	
+	}
+
+
+
+/**************************************************************************/
+//
+//	CUssdMessagingDMmTsy
+//
+/**************************************************************************/
+
+CUssdMessagingDMmTsy* CUssdMessagingDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)
+	{
+	CUssdMessagingDMmTsy* subsession=new(ELeave) CUssdMessagingDMmTsy(aPhone,aFac,aName);
+	CleanupStack::PushL(subsession);
+	subsession->ConstructL();
+	CleanupStack::Pop();
+	return subsession;
+	}
+
+void CUssdMessagingDMmTsy::Init()
+	{}
+
+CUssdMessagingDMmTsy::CUssdMessagingDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac, const TDesC& aName)
+	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)
+	{
+	iMessagingName=aName;
+	}
+
+void CUssdMessagingDMmTsy::ConstructL()
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy created"));
+	}
+
+CUssdMessagingDMmTsy::~CUssdMessagingDMmTsy()
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy destroyed"));
+	}
+
+CTelObject* CUssdMessagingDMmTsy::OpenNewObjectByNameL(const TDesC& /*aName*/)
+	{
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CTelObject* CUssdMessagingDMmTsy::OpenNewObjectL(TDes&)
+	{
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CTelObject::TReqMode CUssdMessagingDMmTsy::ReqModeL(const TInt aIpc)
+	{
+	CTelObject::TReqMode ret=0;
+	switch (aIpc)
+		{
+//
+// Non-Flow Controlled Services
+//
+	case EMobileUssdMessagingGetCaps:
+		break;
+//
+// Flow Controlled Services
+//
+	case EMobileUssdMessagingSendMessage:
+	case EMobileUssdMessagingSendMessageNoFdnCheck:
+	case EMobileUssdMessagingSendRelease:
+		ret=KReqModeFlowControlObeyed;
+		break;
+
+//
+// Immediate Server Repost
+//
+	case EMobileUssdMessagingReceiveMessage:
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		ret=KReqModeRePostImmediately;
+		break;
+//
+// Cancel Requests
+//	
+	case EMobileUssdMessagingReceiveMessageCancel:
+	case EMobileUssdMessagingSendMessageCancel:
+	case EMobileUssdMessagingSendMessageNoFdnCheckCancel:
+	case EMobileUssdMessagingSendReleaseCancel:
+	case EMobileUssdMessagingNotifyNetworkReleaseCancel:
+	default:
+		User::Leave(KErrNotSupported);
+		break;
+		}
+
+	return ret;
+	}
+
+TInt CUssdMessagingDMmTsy::RegisterNotification(const TInt aIpc)
+	{
+	switch (aIpc)
+		{
+	case EMobileUssdMessagingReceiveMessage:
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: RegisterNotification - Receive USSD"));
+		return KErrNone;
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: RegisterNotification - Notify Network Release"));
+		return KErrNone;		
+	default:
+		// Unknown or invalid IPC
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: Register error, unknown IPC"));
+		return KErrNotSupported;
+		}
+	}
+
+TInt CUssdMessagingDMmTsy::DeregisterNotification(const TInt aIpc)
+	{
+	switch (aIpc)
+		{
+	case EMobileUssdMessagingReceiveMessage:
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: DeregisterNotification - Receive USSD"));
+		return KErrNone;
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: DeregisterNotification - Notify Network Release"));
+		return KErrNone;
+	default:
+		// Unknown or invalid IPC
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: Deregister error, unknown IPC"));
+		return KErrNotSupported;
+		}
+	}
+
+TInt CUssdMessagingDMmTsy::NumberOfSlotsL(const TInt aIpc)
+	{
+	TInt numberOfSlots=1;
+	switch (aIpc)
+		{
+	case EMobileUssdMessagingReceiveMessage:
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: Registered with 2 slot"));
+		numberOfSlots=2;
+		break;
+	default:
+		// Unknown or invalid Phone IPC
+		LOGTEXT(_L8("CUssdMessagingDMmTsy: Number of Slots error, unknown IPC"));
+		User::Leave(KErrNotSupported);
+		break;
+		}
+	return numberOfSlots;
+	}
+
+
+TInt CUssdMessagingDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,
+							  const TDataPackage& aPackage)
+	{
+	switch (aIpc)
+		{
+
+	case EMobileUssdMessagingGetCaps:
+		return GetCaps(aTsyReqHandle, aPackage.Des1n());
+
+	case EMobileUssdMessagingSendMessage:
+		return SendMessage(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());
+
+	case EMobileUssdMessagingSendMessageNoFdnCheck:
+		return SendMessageNoFdnCheck(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());
+
+	case EMobileUssdMessagingReceiveMessage:
+		return ReceiveMessage(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());
+	case EMobileUssdMessagingSendRelease:
+		return SendRelease(aTsyReqHandle, aPackage.Des1n()); 
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		switch(aPackage.Type())
+			{
+		// Switch between the alternative implementations of GetPhoneStoreInfo
+		case TDataPackage::EPackage1n:
+			return NotifyNetworkRelease(aTsyReqHandle, aPackage.Des1n()); 
+		case TDataPackage::EPackage1n2n:
+			return NotifyNetworkRelease(aTsyReqHandle, aPackage.Des1n(),aPackage.Des2n()); 
+		default:
+			return KErrCorrupt;
+			}
+
+//
+// Cancel Requests
+//	
+	case EMobileUssdMessagingReceiveMessageCancel:
+		return ReceiveMessageCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendMessageCancel:
+		return SendMessageCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendMessageNoFdnCheckCancel:
+		return SendMessageNoFdnCheckCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendReleaseCancel:
+		return SendReleaseCancel(aTsyReqHandle);
+	case EMobileUssdMessagingNotifyNetworkReleaseCancel:
+		return NotifyNetworkReleaseCancel(aTsyReqHandle);
+
+	default:
+		return KErrNotSupported;
+		}
+	}
+
+TInt CUssdMessagingDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy: - CancelService called"));
+	switch (aIpc)
+		{
+	case EMobileUssdMessagingReceiveMessage:
+		return ReceiveMessageCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendMessage:
+		return SendMessageCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendMessageNoFdnCheck:
+		return SendMessageNoFdnCheckCancel(aTsyReqHandle);
+	case EMobileUssdMessagingSendRelease:
+		return SendReleaseCancel(aTsyReqHandle);
+	case EMobileUssdMessagingNotifyNetworkRelease:
+		return NotifyNetworkReleaseCancel(aTsyReqHandle);
+	default:
+		return KErrGeneral; 
+		}
+	}
+
+TInt CUssdMessagingDMmTsy::GetCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::GetCaps called"));
+	RMobileUssdMessaging::TMobileUssdCapsV1Pckg* ussdCapsPckg = (RMobileUssdMessaging::TMobileUssdCapsV1Pckg*)aCaps;
+	RMobileUssdMessaging::TMobileUssdCapsV1& ussdCaps = (*ussdCapsPckg)();
+
+	ussdCaps.iUssdTypes=DMMTSY_USSD_MESSAGING_TYPE_CAPS;
+
+	ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::ReceiveMessage(const TTsyReqHandle aTsyReqHandle, TDes8* aMsgData, TDes8* aMsgAttributes)
+	{
+	if (!iReceiveMessage++)
+		{
+		LOGTEXT(_L8("CUssdMessagingDMmTsy::ReceiveMessage called"));
+		RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileUssdMessaging::TMobileUssdAttributesV1Pckg*,aMsgAttributes);
+		RMobileUssdMessaging::TMobileUssdAttributesV1& atts = (*attsPckg)();
+
+		*aMsgData = DMMTSY_USSD_MESSAGE_PDU;
+
+		atts.iFlags = DMMTSY_USSD_ATTRIBUTE_FLAGS;
+		atts.iFormat = DMMTSY_USSD_ATTRIBUTE_FORMAT;
+		atts.iType = DMMTSY_USSD_ATTRIBUTE_TYPE;
+		atts.iDcs = DMMTSY_USSD_ATTRIBUTE_DCS;
+
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+		}
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::ReceiveMessageCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::ReceiveMessageCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::SendMessage(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsgData, TDesC8* aMsgAttributes)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendMessage called"));
+	RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileUssdMessaging::TMobileUssdAttributesV1Pckg*,aMsgAttributes);
+	RMobileUssdMessaging::TMobileUssdAttributesV1& atts = (*attsPckg)();
+	if ((aMsgData->Compare(DMMTSY_USSD_MESSAGE_PDU) != 0) ||
+		atts.iFlags != DMMTSY_USSD_ATTRIBUTE_FLAGS || 
+		atts.iFormat != DMMTSY_USSD_ATTRIBUTE_FORMAT ||
+		atts.iType != DMMTSY_USSD_ATTRIBUTE_TYPE ||
+		atts.iDcs != DMMTSY_USSD_ATTRIBUTE_DCS)
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::SendMessageCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendMessageCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::SendMessageNoFdnCheck(const TTsyReqHandle aTsyReqHandle, TDesC8* aMsgData, TDesC8* aMsgAttributes)
+	/**
+	* This method sends an outgoing SMS to the network. The number used for sending the SMS   
+	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+	*
+	* @param aMsgData Supplies the TPDU to send
+	* @param aMsgAttributes Supplies the attributes of the outgoing message
+	*/
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendMessageNoFdnCheck called"));
+	RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileUssdMessaging::TMobileUssdAttributesV1Pckg*,aMsgAttributes);
+	RMobileUssdMessaging::TMobileUssdAttributesV1& atts = (*attsPckg)();
+	if ((aMsgData->Compare(DMMTSY_USSD_MESSAGE_PDU) != 0) ||
+		atts.iFlags != DMMTSY_USSD_ATTRIBUTE_FLAGS || 
+		atts.iFormat != DMMTSY_USSD_ATTRIBUTE_FORMAT ||
+		atts.iType != DMMTSY_USSD_ATTRIBUTE_TYPE ||
+		atts.iDcs != DMMTSY_USSD_ATTRIBUTE_DCS)
+		ReqCompleted(aTsyReqHandle,KErrCorrupt);
+	else
+		iPhone->AddDelayedReq(aTsyReqHandle,this);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::SendMessageNoFdnCheckCancel(const TTsyReqHandle aTsyReqHandle)
+	/**
+	* This method cancels the sending of an outgoing SMS to the network. The number used for sending the SMS   
+	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled
+	*
+	*/
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendMessageNoFdnCheckCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+TInt CUssdMessagingDMmTsy::SendRelease(const TTsyReqHandle aTsyReqHandle, TDes8* aReturnResult)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendRelease called"));
+	if (!iSendRelease++)
+		{
+		RMobilePhone::TMobilePhoneSendSSRequestV3Pckg* ssRequestPckg = REINTERPRET_CAST(RMobilePhone::TMobilePhoneSendSSRequestV3Pckg*,aReturnResult);
+		RMobilePhone::TMobilePhoneSendSSRequestV3& ssRequest = (*ssRequestPckg)();
+			
+		if(ssRequest.ExtensionId()!=KETelExtMultimodeV3)
+			ReqCompleted(aTsyReqHandle,KErrCorrupt);
+		else
+			{	
+			ssRequest.iOpCode = DMMTSY_PHONE_NOTIFY_OPCODE;
+			ssRequest.iAdditionalInfo = DMMTSY_PHONE_NOTIFY_ADDINFO;			
+			ReqCompleted(aTsyReqHandle,KErrNone);
+			}
+		}
+	return KErrNone;
+	}
+	
+TInt CUssdMessagingDMmTsy::SendReleaseCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::SendReleaseCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+	
+TInt CUssdMessagingDMmTsy::NotifyNetworkRelease(const TTsyReqHandle aTsyReqHandle, TDes8* aReturnResult)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::NotifyNetworkRelease (deprecated version) called"));
+	if (!iNetworkRelease++)
+		{
+		RMobilePhone::TMobilePhoneSendSSRequestV3Pckg* ssRequestPckg = REINTERPRET_CAST(RMobilePhone::TMobilePhoneSendSSRequestV3Pckg*,aReturnResult);
+		RMobilePhone::TMobilePhoneSendSSRequestV3& ssRequest = (*ssRequestPckg)();
+			
+		if(ssRequest.ExtensionId()!=KETelExtMultimodeV3)
+			ReqCompleted(aTsyReqHandle,KErrCorrupt);
+		else
+			{	
+			ssRequest.iOpCode = DMMTSY_PHONE_NOTIFY_OPCODE;
+			ssRequest.iAdditionalInfo = DMMTSY_PHONE_NOTIFY_ADDINFO;			
+			ReqCompleted(aTsyReqHandle,KErrNone);
+			}
+		}
+	return KErrNone;
+	}
+	
+TInt CUssdMessagingDMmTsy::NotifyNetworkReleaseCancel(const TTsyReqHandle aTsyReqHandle)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::NotifyNetworkReleaseCancel called"));
+	iPhone->RemoveDelayedReq(aTsyReqHandle);
+	ReqCompleted(aTsyReqHandle,KErrCancel);
+	return KErrNone;
+	}
+	
+TInt CUssdMessagingDMmTsy::NotifyNetworkRelease(const TTsyReqHandle aTsyReqHandle, TDes8* aReturnResult, TDes8* aMsgAttributes)
+	{
+	LOGTEXT(_L8("CUssdMessagingDMmTsy::NotifyNetworkRelease called"));
+	if (iNetworkRelease >= 2)
+	{
+		iNetworkRelease = 0;
+	}
+	
+	if (!iNetworkRelease++)
+		{
+		RMobilePhone::TMobilePhoneSendSSRequestV3Pckg* ssRequestPckg = REINTERPRET_CAST(RMobilePhone::TMobilePhoneSendSSRequestV3Pckg*,aReturnResult);
+		RMobilePhone::TMobilePhoneSendSSRequestV3& ssRequest = (*ssRequestPckg)();
+		
+		RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* ssMsgAttributesPckg = REINTERPRET_CAST(RMobileUssdMessaging::TMobileUssdAttributesV1Pckg*,aMsgAttributes);
+		RMobileUssdMessaging::TMobileUssdAttributesV1& ssMsgAttributesReq = (*ssMsgAttributesPckg)();
+									
+		if ((ssRequest.ExtensionId()!=KETelExtMultimodeV3) || (ssMsgAttributesReq.ExtensionId()!=KETelExtMultimodeV1))
+			{
+			ReqCompleted(aTsyReqHandle,KErrCorrupt);
+			}
+		else
+			{	
+			ssRequest.iOpCode = DMMTSY_PHONE_NOTIFY_OPCODE;
+			ssRequest.iAdditionalInfo = DMMTSY_PHONE_NOTIFY_ADDINFO;
+												
+			ssMsgAttributesReq.iFlags  = DMMTSY_USSD_ATTRIBUTE_FLAGS;
+			ssMsgAttributesReq.iFormat = DMMTSY_USSD_ATTRIBUTE_FORMAT;
+			ssMsgAttributesReq.iType   = DMMTSY_USSD_ATTRIBUTE_TYPE;
+			ssMsgAttributesReq.iDcs    = DMMTSY_USSD_ATTRIBUTE_DCS;
+											
+			ReqCompleted(aTsyReqHandle,KErrNone);
+			}
+		}
+	return KErrNone;
+	}