1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "mmtsy.h"

    17 #include "testdef.h"

    18 #include "ETELMM.H"

    19 #include <et_clsvr.h>

    20 #include "Dmmlog.h"

    21 

    22 /**************************************************************************/

    23 //

    24 //	CSmsMessagingDMmTsy

    25 //

    26 /**************************************************************************/

    27 

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

    29 	{

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

    31 	CleanupStack::PushL(subsession);

    32 	subsession->ConstructL();

    33 	CleanupStack::Pop();

    34 	return subsession;

    35 	}

    36 

    37 void CSmsMessagingDMmTsy::Init()

    38 	{}

    39 

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

    41 	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)

    42 	{

    43 	iMessagingName=aName;

    44 	}

    45 

    46 void CSmsMessagingDMmTsy::ConstructL()

    47 	{

    48 	LOGTEXT(_L8("CSmsMessagingDMmTsy created"));

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

    50 	}

    51 

    52 CSmsMessagingDMmTsy::~CSmsMessagingDMmTsy()

    53 	{

    54 	LOGTEXT(_L8("CSmsMessagingDMmTsy destroyed"));

    55 	if (iSmspReadAll)

    56 		iSmspReadAll->ResetAndDestroy();

    57 	delete iSmspReadAll;

    58 	}

    59 

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

    61 	{

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

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

    64 

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

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

    67 	

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

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

    70 

    71 	return NULL;

    72 	}

    73 

    74 CTelObject* CSmsMessagingDMmTsy::OpenNewObjectL(TDes&)

    75 	{

    76 	// Open objects without a name is not supported

    77 	User::Leave(KErrNotSupported);

    78 	return NULL;

    79 	}

    80 

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

    82 	{

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

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

    85 

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

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

    88 	// "sensible" values in this test code

    89 

    90 	CTelObject::TReqMode ret=0;

    91 	switch (aIpc)

    92 		{

    93 

    94 //

    95 // Non-flow Controlled Services

    96 //

    97 	case EMobileSmsMessagingGetCaps:

    98 	case EMobileSmsMessagingGetReceiveMode:

    99 	case EMobileSmsMessagingGetMoSmsBearer:

   100 	case EMobileSmsMessagingEnumerateMessageStores:

   101 	case EMobileSmsMessagingGetMessageStoreInfo:

   102 	case EMobileSmsMessagingResumeSmsReception:

   103 	case EMobileSmsMessagingGetSmspListPhase2:

   104 		break;

   105 

   106 //

   107 // Flow Controlled Services

   108 //

   109 	case EMobileSmsMessagingSetReceiveMode:

   110 	case EMobileSmsMessagingSetMoSmsBearer:

   111 	case EMobileSmsMessagingAckSmsStored:

   112 	case EMobileSmsMessagingNackSmsStored:

   113 	case EMobileSmsMessagingSendMessage:

   114 	case EMobileSmsMessagingSendMessageNoFdnCheck:

   115 	case EMobileSmsMessagingGetSmspListPhase1:

   116 	case EMobileSmsMessagingStoreSmspList:

   117 		ret=KReqModeFlowControlObeyed;

   118 		break;

   119 

   120 //

   121 //  Immediate server repost of request

   122 //

   123 	case EMobileSmsMessagingReceiveMessage:

   124 		ret=KReqModeRePostImmediately;

   125 		break;

   126 //

   127 // Multiple Completion Services with Immediate Server Repost

   128 // (Usually Notifications)

   129 //

   130 	case EMobileSmsMessagingNotifyReceiveModeChange:

   131 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

   132 	case EMobileSmsMessagingNotifySmspListChange:

   133 		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   134 		break;

   135 

   136 //

   137 // Cancel Requests

   138 //	

   139 	case EMobileSmsMessagingSetReceiveModeCancel:

   140 	case EMobileSmsMessagingNotifyReceiveModeChangeCancel:

   141 	case EMobileSmsMessagingNotifyMoSmsBearerChangeCancel:

   142 	case EMobileSmsMessagingAckSmsStoredCancel:

   143 	case EMobileSmsMessagingNackSmsStoredCancel:

   144 	case EMobileSmsMessagingSendMessageCancel:

   145 	case EMobileSmsMessagingSendMessageNoFdnCheckCancel:

   146 	case EMobileSmsMessagingGetMessageStoreInfoCancel:

   147 	case EMobileSmsMessagingGetSmspListCancel:

   148 	case EMobileSmsMessagingStoreSmspListCancel:

   149 	case EMobileSmsMessagingNotifySmspListChangeCancel:

   150 	default:

   151 		User::Leave(KErrNotSupported);

   152 		break;

   153 		}

   154 

   155 	return ret;

   156 	}

   157 

   158 TInt CSmsMessagingDMmTsy::RegisterNotification(const TInt aIpc)

   159 	{

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

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

   162 

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

   164 	// receive from the phone

   165 

   166 	switch (aIpc)

   167 		{

   168 	case EMobileSmsMessagingNotifySmspListChange:

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

   170 		return KErrNone;

   171 	case EMobileSmsMessagingNotifyReceiveModeChange:

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

   173 		return KErrNone;

   174 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

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

   176 		return KErrNone;

   177 	case EMobileSmsMessagingReceiveMessage:

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

   179 		return KErrNone;

   180 	default:

   181 		// Unknown or invalid IPC

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

   183 		return KErrNotSupported;

   184 		}

   185 	}

   186 

   187 TInt CSmsMessagingDMmTsy::DeregisterNotification(const TInt aIpc)

   188 	{

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

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

   191 	// object has just closed the handle.

   192 

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

   194 	// receive from the phone

   195 

   196 	switch (aIpc)

   197 		{

   198 	case EMobileSmsMessagingNotifySmspListChange:

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

   200 		return KErrNone;

   201 	case EMobileSmsMessagingNotifyReceiveModeChange:

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

   203 		return KErrNone;

   204 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

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

   206 		return KErrNone;

   207 	case EMobileSmsMessagingReceiveMessage:

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

   209 		return KErrNone;

   210 	default:

   211 		// Unknown or invalid IPC

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

   213 		return KErrNotSupported;

   214 		}

   215 	}

   216 

   217 TInt CSmsMessagingDMmTsy::NumberOfSlotsL(const TInt aIpc)

   218 	{

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

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

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

   222 

   223 	TInt numberOfSlots=1;

   224 	switch (aIpc)

   225 		{

   226 	case EMobileSmsMessagingNotifySmspListChange:

   227 	case EMobileSmsMessagingNotifyReceiveModeChange:

   228 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

   229 	case EMobileSmsMessagingReceiveMessage:

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

   231 		numberOfSlots=2;

   232 		break;

   233 	default:

   234 		// Unknown or invalid Phone IPC

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

   236 		User::Leave(KErrNotSupported);

   237 		break;

   238 		}

   239 	return numberOfSlots;

   240 	}

   241 

   242 

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

   244 							  const TDataPackage& aPackage)

   245 	{

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

   247 	// for the TSY to process

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

   249 

   250 	TAny* dataPtr=aPackage.Ptr1();

   251 	TAny* dataPtr2=aPackage.Ptr2();

   252 

   253 	switch (aIpc)

   254 		{

   255 	case EMobileSmsMessagingGetCaps:

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

   257 

   258 	case EMobileSmsMessagingEnumerateMessageStores:

   259 		return EnumerateMessageStores(aTsyReqHandle, 

   260 			REINTERPRET_CAST(TInt*, dataPtr));

   261 

   262 	case EMobileSmsMessagingGetMessageStoreInfo:

   263 		return GetMessageStoreInfo(aTsyReqHandle, 

   264 			REINTERPRET_CAST(TInt*, dataPtr),

   265 			aPackage.Des2n());

   266 

   267 	case EMobileSmsMessagingReceiveMessage:

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

   269 

   270 	case EMobileSmsMessagingAckSmsStored:

   271 		return AckSmsStored(aTsyReqHandle, aPackage.Des1n(),

   272 			REINTERPRET_CAST(TBool*, dataPtr2));

   273 

   274 	case EMobileSmsMessagingNackSmsStored:

   275 		return NackSmsStored(aTsyReqHandle, aPackage.Des1n(),

   276 			REINTERPRET_CAST(TInt*, dataPtr2));

   277 

   278 	case EMobileSmsMessagingResumeSmsReception:

   279 		return ResumeSmsReception(aTsyReqHandle);

   280 

   281 	case EMobileSmsMessagingSendMessage:

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

   283 

   284 	case EMobileSmsMessagingSendMessageNoFdnCheck:

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

   286 

   287 	case EMobileSmsMessagingGetSmspListPhase1:

   288 		return ReadSmspListPhase1(aTsyReqHandle,

   289 			REINTERPRET_CAST(RMobilePhone::TClientId*,dataPtr),

   290 			REINTERPRET_CAST(TInt*,dataPtr2));

   291 

   292 	case EMobileSmsMessagingGetSmspListPhase2:

   293 		return ReadSmspListPhase2(aTsyReqHandle,

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

   295 

   296 	case EMobileSmsMessagingStoreSmspList:

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

   298 

   299 	case EMobileSmsMessagingNotifySmspListChange:

   300 		return NotifySmspListChange(aTsyReqHandle);

   301 

   302 	case EMobileSmsMessagingGetReceiveMode:

   303 		return GetReceiveMode(aTsyReqHandle,

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

   305 

   306 	case EMobileSmsMessagingSetReceiveMode:

   307 		return SetReceiveMode(aTsyReqHandle,

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

   309 

   310 	case EMobileSmsMessagingNotifyReceiveModeChange:

   311 		return NotifyReceiveModeChange(aTsyReqHandle,

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

   313 

   314 	case EMobileSmsMessagingGetMoSmsBearer:

   315 		return GetMoSmsBearer(aTsyReqHandle,

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

   317 

   318 	case EMobileSmsMessagingSetMoSmsBearer:

   319 		return SetMoSmsBearer(aTsyReqHandle,

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

   321 

   322 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

   323 		return NotifyMoSmsBearerChange(aTsyReqHandle,

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

   325 

   326 	default:

   327 		return KErrNotSupported;

   328 		}

   329 	}

   330 

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

   332 	{

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

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

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

   336 	// asynchronous requests.

   337 

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

   339 	switch (aIpc)

   340 		{

   341 	case EMobileSmsMessagingReceiveMessage:

   342 		return ReceiveMessageCancel(aTsyReqHandle);

   343 	case EMobileSmsMessagingAckSmsStored:

   344 		return AckSmsStoredCancel(aTsyReqHandle);

   345 	case EMobileSmsMessagingNackSmsStored:

   346 		return NackSmsStoredCancel(aTsyReqHandle);

   347 	case EMobileSmsMessagingSendMessage:

   348 		return SendMessageCancel(aTsyReqHandle);

   349 	case EMobileSmsMessagingSendMessageNoFdnCheck:

   350 		return SendMessageNoFdnCheckCancel(aTsyReqHandle);

   351 	case EMobileSmsMessagingGetMessageStoreInfo:

   352 		return GetMessageStoreInfoCancel(aTsyReqHandle);

   353 	case EMobileSmsMessagingGetSmspListPhase1:

   354 	case EMobileSmsMessagingGetSmspListPhase2:

   355 		return ReadSmspListCancel(aTsyReqHandle);

   356 	case EMobileSmsMessagingStoreSmspList:

   357 		return StoreSmspListCancel(aTsyReqHandle);

   358 	case EMobileSmsMessagingNotifySmspListChange:

   359 		return NotifySmspListChangeCancel(aTsyReqHandle);

   360 	case EMobileSmsMessagingSetReceiveMode:

   361 		return SetReceiveModeCancel(aTsyReqHandle);

   362 	case EMobileSmsMessagingNotifyReceiveModeChange:

   363 		return NotifyReceiveModeChangeCancel(aTsyReqHandle);

   364 	case EMobileSmsMessagingSetMoSmsBearer:

   365 		return SetMoSmsBearerCancel(aTsyReqHandle);

   366 	case EMobileSmsMessagingNotifyMoSmsBearerChange:

   367 		return NotifyMoSmsBearerChangeCancel(aTsyReqHandle);

   368 	default:

   369 		return KErrGeneral; 

   370 		}

   371 	}

   372 

   373 

   374 /***********************************************************************************/

   375 //

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

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

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

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

   380 //

   381 /***********************************************************************************/

   382 

   383 

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

   385 	{

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

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

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

   389 

   390 	smsCaps.iSmsMode=DMMTSY_SMS_MESSAGING_MODE_CAPS;

   391 	smsCaps.iSmsControl=DMMTSY_SMS_MESSAGING_CONTROL_CAPS;

   392 

   393 	ReqCompleted(aTsyReqHandle,KErrNone);

   394 	return KErrNone;

   395 	}

   396 

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

   398 	{

   399 	if (!iReceiveMessage++)

   400 		{

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

   402 	

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

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

   405 

   406 		atts.iFlags=DMMTSY_SMS_MESSAGE_FLAGS1;

   407 		atts.iDataFormat=DMMTSY_SMS_MESSAGE_FORMAT1;

   408 		atts.iGsmServiceCentre.iTelNumber=DMMTSY_SMS_MESSAGE_SC1;

   409 		atts.iOriginator.iTelNumber=DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER1;

   410 		atts.iStatus=DMMTSY_SMS_MESSAGE_STATUS1;

   411 		atts.iStore=DMMTSY_MESSAGE_STORE_NAME;

   412 		atts.iStoreIndex=DMMTSY_SMS_STORE_INDEX1;

   413 

   414 		aMsg->Copy(DMMTSY_SMS_MESSAGE_PDU1);

   415 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   416 		}

   417 	return KErrNone;

   418 	}

   419 

   420 TInt CSmsMessagingDMmTsy::ReceiveMessageCancel(const TTsyReqHandle aTsyReqHandle)

   421 	{

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

   423 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   424 	ReqCompleted(aTsyReqHandle,KErrCancel);

   425 	return KErrNone;

   426 	}

   427 

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

   429 	{

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

   431 

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

   433 		(*aFull != DMMTSY_SMS_MESSAGE_FULL))

   434 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   435 	else

   436 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   437 	return KErrNone;

   438 	}

   439 

   440 TInt CSmsMessagingDMmTsy::AckSmsStoredCancel(const TTsyReqHandle aTsyReqHandle)

   441 	{

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

   443 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   444 	ReqCompleted(aTsyReqHandle,KErrCancel);

   445 	return KErrNone;

   446 	}

   447 

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

   449 	{

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

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

   452 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   453 	else

   454 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   455 	return KErrNone;

   456 	}

   457 

   458 TInt CSmsMessagingDMmTsy::NackSmsStoredCancel(const TTsyReqHandle aTsyReqHandle)

   459 	{

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

   461 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   462 	ReqCompleted(aTsyReqHandle,KErrCancel);

   463 	return KErrNone;

   464 	}

   465 

   466 TInt CSmsMessagingDMmTsy::ResumeSmsReception(const TTsyReqHandle aTsyReqHandle)

   467 	{

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

   469 	ReqCompleted(aTsyReqHandle,KErrNone);

   470 	return KErrNone;

   471 	}

   472 

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

   474 	{

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

   476 

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

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

   479 	

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

   481 		{

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

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

   484 

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

   486 			(attsV1.iDataFormat != DMMTSY_SMS_MESSAGE_FORMAT1) ||

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

   488 			(attsV1.iMore != DMMTSY_SMS_MESSAGE_MORE) ||

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

   490 			{

   491 			ReqCompleted(aTsyReqHandle, KErrCorrupt);

   492 			}

   493 		else

   494 			{

   495 			attsV1.iMsgRef = DMMTSY_SMS_MESSAGE_MSGREF;

   496 			attsV1.iSubmitReport = DMMTSY_SMS_MESSAGE_PDU2;

   497 			iPhone->AddDelayedReq(aTsyReqHandle, this);

   498 			}

   499 		}

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

   501 		{

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

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

   504 

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

   506 			(attsV4.iDataFormat != DMMTSY_SMS_MESSAGE_CDMA_FORMAT) ||

   507 			(attsV4.iCdmaTeleservice != DMMTSY_SMS_MESSAGE_CDMA_TELESERVICE) ||

   508 			(attsV4.iCdmaServiceCategory != DMMTSY_SMS_MESSAGE_CDMA_SERVICE_CATEGORY) ||

   509 			(attsV4.iMore != DMMTSY_SMS_MESSAGE_MORE) ||

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

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

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

   513 			(attsV4.iAddressAuthentication != DMMTSY_SMS_MESSAGE_ADDRESS_AUTHENTICATION) ||

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

   515 			{

   516 			ReqCompleted(aTsyReqHandle, KErrCorrupt);

   517 			}

   518 		else

   519 			{

   520 			attsV4.iMsgRef = DMMTSY_SMS_MESSAGE_MSGREF;

   521 			attsV4.iTLAck = DMMTSY_SMS_MESSAGE_TLACK;

   522 			iPhone->AddDelayedReq(aTsyReqHandle, this);

   523 			}

   524 		}

   525 	else

   526 		{

   527 		ReqCompleted(aTsyReqHandle, KErrCorrupt);

   528 		}

   529 	return KErrNone;

   530 	}

   531 

   532 TInt CSmsMessagingDMmTsy::SendMessageCancel(const TTsyReqHandle aTsyReqHandle)

   533 	{

   534 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageCancel called"));

   535 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   536 	ReqCompleted(aTsyReqHandle,KErrCancel);

   537 	return KErrNone;

   538 	}

   539 

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

   541 	/**

   542 	* This method sends an outgoing SMS to the network. The number used for sending the SMS   

   543 	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled

   544 	*

   545 	* @param aMsg Supplies the TPDU to send

   546 	* @param aMsgAttributes Supplies the attributes of the outgoing message

   547 	*/

   548 	{

   549 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageNoFdnCheck called"));

   550 	

   551 	RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg* attsPckg = REINTERPRET_CAST(RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg*, aMsgAttributes);

   552 	RMobileSmsMessaging::TMobileSmsSendAttributesV1& atts = (*attsPckg)();

   553 

   554 	if ((atts.iFlags != DMMTSY_SMS_MESSAGE_FLAGS2) ||

   555 		(atts.iDataFormat != DMMTSY_SMS_MESSAGE_FORMAT1) ||

   556 		(atts.iDestination.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) != 0) ||

   557 		(atts.iMore != DMMTSY_SMS_MESSAGE_MORE) ||

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

   559 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   560 	else

   561 		{

   562 		atts.iMsgRef=DMMTSY_SMS_MESSAGE_MSGREF;

   563 		atts.iSubmitReport=DMMTSY_SMS_MESSAGE_PDU2;

   564 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   565 		}

   566 	return KErrNone;

   567 	}

   568 

   569 TInt CSmsMessagingDMmTsy::SendMessageNoFdnCheckCancel(const TTsyReqHandle aTsyReqHandle)

   570 	/**

   571 	* This method cancels the sending of an outgoing SMS to the network. The number used for sending the SMS   

   572 	* is not checked against those in the Fixed Dialling Number list even if the FDN service is enabled

   573 	*

   574 	*/

   575 	{

   576 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SendMessageNoFdnCheckCancel called"));

   577 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   578 	ReqCompleted(aTsyReqHandle,KErrCancel);

   579 	return KErrNone;

   580 	}

   581 

   582 TInt CSmsMessagingDMmTsy::EnumerateMessageStores(const TTsyReqHandle aTsyReqHandle, TInt* aCount)

   583 	{

   584 	LOGTEXT(_L8("CSmsMessagingDMmTsy::EnumerateMessageStores called"));

   585 	*aCount=DMMTSY_PHONE_MESSAGE_STORE_COUNT;

   586 	ReqCompleted(aTsyReqHandle,KErrNone);

   587 	return KErrNone;

   588 	}

   589 

   590 TInt CSmsMessagingDMmTsy::GetMessageStoreInfo(const TTsyReqHandle aTsyReqHandle, TInt *aIndex, TDes8* aInfo)

   591 	{

   592 	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMessageStoreInfo called"));

   593 	

   594 	if (*aIndex != DMMTSY_SMS_STORE_INDEX1)

   595 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   596 	else

   597 		{

   598 		RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg* infoPckg = REINTERPRET_CAST(RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*, aInfo);

   599 		RMobilePhoneStore::TMobilePhoneStoreInfoV1& info = (*infoPckg)();

   600 

   601 		info.iName=DMMTSY_MESSAGE_STORE_NAME;

   602 		info.iType=DMMTSY_MESSAGE_STORE_TYPE;

   603 		info.iTotalEntries=DMMTSY_MESSAGE_STORE_TOTAL_ENTRIES;

   604 		info.iUsedEntries=DMMTSY_MESSAGE_STORE_USED_ENTRIES;

   605 		info.iCaps=DMMTSY_MESSAGE_STORE_CAPS;

   606 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   607 		}

   608 	return KErrNone;

   609 	}

   610 

   611 TInt CSmsMessagingDMmTsy::GetMessageStoreInfoCancel(const TTsyReqHandle aTsyReqHandle)

   612 	{

   613 	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMessageStoreInfoCancel called"));

   614 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   615 	ReqCompleted(aTsyReqHandle,KErrCancel);

   616 	return KErrNone;

   617 	}

   618 

   619 TInt CSmsMessagingDMmTsy::ValidateSmspEntry(const RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)

   620 	{

   621 	if ((aEntry.iText != DMMTSY_SMSP_STORE_TEXT1) ||

   622 		(aEntry.iValidParams != DMMTSY_SMSP_STORE_VALID_PARAMS1) ||

   623 		(aEntry.iDestination.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) != 0) ||

   624 		(aEntry.iValidityPeriod != DMMTSY_SMSP_STORE_VALIDITY1) ||

   625 		(aEntry.iServiceCentre.iTelNumber.Compare(DMMTSY_SMSP_STORE_SCA) != 0) ||

   626 		(aEntry.iProtocolId != DMMTSY_SMSP_STORE_PID1) ||

   627 		(aEntry.iDcs != DMMTSY_SMSP_STORE_DCS1))

   628 		return KErrCorrupt;

   629 	else

   630 		return KErrNone;

   631 	}

   632 

   633 void CSmsMessagingDMmTsy::InitSmspEntry(RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)

   634 	{

   635 	aEntry.iText = DMMTSY_SMSP_STORE_TEXT1;

   636 	aEntry.iValidParams = DMMTSY_SMSP_STORE_VALID_PARAMS1;

   637 	aEntry.iDestination.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

   638 	aEntry.iValidityPeriod = DMMTSY_SMSP_STORE_VALIDITY1;

   639 	aEntry.iServiceCentre.iTelNumber = DMMTSY_SMSP_STORE_SCA;

   640 	aEntry.iProtocolId = DMMTSY_SMSP_STORE_PID1;

   641 	aEntry.iDcs = DMMTSY_SMSP_STORE_DCS1;

   642 	}

   643 

   644 

   645 TInt CSmsMessagingDMmTsy::ReadSmspListPhase1(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aId, TInt* aBufSize)

   646 	{

   647 	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListPhase1 called"));

   648 	TInt ret=KErrNone;

   649 	TInt leaveCode=KErrNone;

   650 	TRAP(leaveCode, ret=ProcessReadSmspListPhase1L(aTsyReqHandle, aId, aBufSize););

   651 	if (leaveCode != KErrNone)

   652 		ReqCompleted(aTsyReqHandle,leaveCode);

   653 	return ret;

   654 	};

   655 

   656 TInt CSmsMessagingDMmTsy::ProcessReadSmspListPhase1L(const TTsyReqHandle aTsyReqHandle, 

   657 											 RMobilePhone::TClientId* aId, 

   658 											 TInt* aBufSize)

   659 	{

   660 	// read the list, store its content and then return size of this buffer to client

   661 	CMobilePhoneSmspList* list=CMobilePhoneSmspList::NewL();

   662 	CleanupStack::PushL(list);

   663 

   664 	RMobileSmsMessaging::TMobileSmspEntryV1 entry;

   665 

   666 	// fill up an example list

   667 	for (TInt index=0; index < DMMTSY_SMSP_STORE_COUNT; index++)

   668 		{

   669 		switch (index)

   670 			{

   671 		case 0:

   672 			InitSmspEntry(entry);

   673 

   674 			entry.iIndex=DMMTSY_SMSP_STORE_INDEX1;

   675 			break;

   676 		case 1:

   677 			InitSmspEntry(entry);

   678 

   679 			entry.iIndex=DMMTSY_SMSP_STORE_INDEX2;

   680 		default:

   681 			break;

   682 			}

   683 			// Add the entry into the list, at the next empty location

   684 			list->AddEntryL(entry);

   685 		}

   686 

   687 	// Store the streamed list and the client ID

   688 	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aId,aTsyReqHandle);

   689 	CleanupStack::PushL(read);

   690 	

   691 	read->iListBuf = list->StoreLC();

   692 	CleanupStack::Pop(); // pop the CBufFlat allocated by StoreLC

   693 	

   694 	iSmspReadAll->AppendL(read);

   695 	CleanupStack::Pop(); // pop the CListReadAllAttempt

   696 	

   697 	// return the CBufFlat’s size to client

   698 	*aBufSize=(read->iListBuf)->Size();

   699 	

   700 	// Complete first phase of list retrieval

   701 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   702 	CleanupStack::PopAndDestroy(); // pop&destroy list

   703 	return KErrNone;

   704 	}

   705 

   706 

   707 TInt CSmsMessagingDMmTsy::ReadSmspListPhase2(TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aId, TDes8* aBuffer)

   708 	{

   709 	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListPhase2 called"));

   710 	CListReadAllAttempt* read=NULL;

   711 	// Find the read attempt from this client

   712 	for (TInt i=0; i<iSmspReadAll->Count(); ++i)

   713 		{

   714 		read = iSmspReadAll->At(i);

   715 		if ((read->iClient.iSessionHandle==aId->iSessionHandle) &&

   716 		    (read->iClient.iSubSessionHandle==aId->iSubSessionHandle))

   717 			{

   718 			TPtr8 bufPtr((read->iListBuf)->Ptr(0));

   719 			// Copy the streamed list to the client

   720 			aBuffer->Copy(bufPtr);

   721 			delete read;

   722 			iSmspReadAll->Delete(i);

   723 			ReqCompleted(aTsyReqHandle,KErrNone);

   724 			return KErrNone;

   725 			}

   726 		}

   727 	// Should handle error case of not finding the matching client from read all phase 1

   728 	return KErrNotFound;

   729 	}

   730 

   731 

   732 TInt CSmsMessagingDMmTsy::ReadSmspListCancel(const TTsyReqHandle aTsyReqHandle)

   733 	{

   734 	LOGTEXT(_L8("CSmsMessagingDMmTsy::ReadSmspListCancel called"));

   735 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   736 	

   737 	// Remove the read all attempt from iSmspReadAll

   738 	CListReadAllAttempt* read=NULL;

   739 	for (TInt i=0; i<iSmspReadAll->Count(); ++i)

   740 		{

   741 		read = iSmspReadAll->At(i);

   742 		if (read->iReqHandle == aTsyReqHandle)

   743 			{

   744 			delete read;

   745 			iSmspReadAll->Delete(i);

   746 			break;

   747 			}

   748 		}

   749 

   750 	ReqCompleted(aTsyReqHandle,KErrCancel);

   751 	return KErrNone;

   752 	}

   753 

   754 TInt CSmsMessagingDMmTsy::StoreSmspList(const TTsyReqHandle aTsyReqHandle, TDes8* aBuffer)

   755 	{

   756 	LOGTEXT(_L8("CSmsMessagingDMmTsy::StoreSmspList called"));

   757 	TInt ret=KErrNone;

   758 	TInt leaveCode=KErrNone;

   759 	TRAP(leaveCode, ret=ProcessStoreSmspListL(aTsyReqHandle, aBuffer););

   760 	if (leaveCode != KErrNone)

   761 		ReqCompleted(aTsyReqHandle,leaveCode);

   762 	return ret;

   763 	};

   764 

   765 TInt CSmsMessagingDMmTsy::ProcessStoreSmspListL(TTsyReqHandle aTsyReqHandle, TDes8* aBuffer)

   766 	{

   767 	CMobilePhoneSmspList* aSmspList=CMobilePhoneSmspList::NewL();

   768 	CleanupStack::PushL(aSmspList);

   769 	

   770 	aSmspList->RestoreL(*aBuffer);

   771 

   772 	RMobileSmsMessaging::TMobileSmspEntryV1 entry;

   773 

   774 	if (aSmspList->Enumerate() != DMMTSY_SMSP_STORE_COUNT)

   775 		{

   776 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   777 		return KErrNone;

   778 		}

   779 

   780 	entry=aSmspList->GetEntryL(0);

   781 

   782 	if ((entry.iIndex != DMMTSY_SMSP_STORE_INDEX1) ||  

   783 		(ValidateSmspEntry(entry) != KErrNone))

   784 		{

   785 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   786 		return KErrNone;

   787 		}

   788 

   789 	entry=aSmspList->GetEntryL(1);

   790 

   791 	if ((entry.iIndex != DMMTSY_SMSP_STORE_INDEX2) ||  

   792 		(ValidateSmspEntry(entry) != KErrNone))

   793 		{

   794 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   795 		return KErrNone;

   796 		}

   797 

   798 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   799 	CleanupStack::PopAndDestroy(); // aSmspList

   800 	return KErrNone;

   801 	}

   802 

   803 TInt CSmsMessagingDMmTsy::StoreSmspListCancel(TTsyReqHandle aTsyReqHandle)

   804 	{

   805 	LOGTEXT(_L8("CSmspStoreDMmTsy::StoreSmspListCancel called"));

   806 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   807 	ReqCompleted(aTsyReqHandle,KErrCancel);

   808 	return KErrNone;

   809 	}

   810 

   811 TInt CSmsMessagingDMmTsy::NotifySmspListChange(const TTsyReqHandle aTsyReqHandle)

   812 	{

   813 	if (!iNotifySmspListChange++)

   814 		{

   815 		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifySmspListChange called"));

   816 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   817 		}

   818 	return KErrNone;

   819 	}

   820 

   821 TInt CSmsMessagingDMmTsy::NotifySmspListChangeCancel(const TTsyReqHandle aTsyReqHandle)

   822 	{

   823 	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifySmspListChangeCancel called"));

   824 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   825 	ReqCompleted(aTsyReqHandle,KErrCancel);

   826 	return KErrNone;	

   827 	}

   828 

   829 

   830 TInt CSmsMessagingDMmTsy::GetReceiveMode(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)

   831 	{

   832 	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetReceiveMode called"));

   833 	*aReceiveMode=DMMTSY_SMS_MESSAGING_RECEIVE_MODE1;

   834 	ReqCompleted(aTsyReqHandle,KErrNone);

   835 	return KErrNone;

   836 	}

   837 

   838 TInt CSmsMessagingDMmTsy::SetReceiveMode(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)

   839 	{

   840 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetReceiveMode called"));

   841 	if ( *aReceiveMode != DMMTSY_SMS_MESSAGING_RECEIVE_MODE1 )

   842 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   843 	else

   844 		{

   845 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   846 		}

   847 	return KErrNone;

   848 	}

   849 

   850 TInt CSmsMessagingDMmTsy::SetReceiveModeCancel(const TTsyReqHandle aTsyReqHandle)

   851 	{

   852 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetReceiveModeCancel called"));

   853 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   854 	ReqCompleted(aTsyReqHandle,KErrCancel);

   855 	return KErrNone;

   856 	}

   857 

   858 TInt CSmsMessagingDMmTsy::NotifyReceiveModeChange(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode)

   859 	{

   860 	if (!iNotifyReceiveModeChange++)

   861 		{

   862 		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyReceiveModeChange called"));

   863 		*aReceiveMode=DMMTSY_SMS_MESSAGING_RECEIVE_MODE2;

   864 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   865 		}

   866 	return KErrNone;

   867 	}

   868 

   869 TInt CSmsMessagingDMmTsy::NotifyReceiveModeChangeCancel(const TTsyReqHandle aTsyReqHandle)

   870 	{

   871 	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyReceiveModeChangeCancel called"));

   872 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   873 	ReqCompleted(aTsyReqHandle,KErrCancel);

   874 	return KErrNone;

   875 	}

   876 

   877 TInt CSmsMessagingDMmTsy::GetMoSmsBearer(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)

   878 	{

   879 	LOGTEXT(_L8("CSmsMessagingDMmTsy::GetMoSmsBearer called"));

   880 	*aBearer=DMMTSY_SMS_MESSAGING_BEARER1;

   881 	ReqCompleted(aTsyReqHandle,KErrNone);

   882 	return KErrNone;

   883 	}

   884 

   885 TInt CSmsMessagingDMmTsy::SetMoSmsBearer(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)

   886 	{

   887 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetMoSmsBearer called"));

   888 	if ( *aBearer != DMMTSY_SMS_MESSAGING_BEARER1 )

   889 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   890 	else

   891 		{

   892 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   893 		}

   894 	return KErrNone;

   895 	}

   896 

   897 TInt CSmsMessagingDMmTsy::SetMoSmsBearerCancel(const TTsyReqHandle aTsyReqHandle)

   898 	{

   899 	LOGTEXT(_L8("CSmsMessagingDMmTsy::SetMoSmsBearerCancel called"));

   900 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   901 	ReqCompleted(aTsyReqHandle,KErrCancel);

   902 	return KErrNone;

   903 	}

   904 

   905 TInt CSmsMessagingDMmTsy::NotifyMoSmsBearerChange(const TTsyReqHandle aTsyReqHandle, RMobileSmsMessaging::TMobileSmsBearer* aBearer)

   906 	{

   907 	if (!iNotifyMoSmsBearerChange++)

   908 		{

   909 		LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyMoSmsBearerChange called"));

   910 		*aBearer=DMMTSY_SMS_MESSAGING_BEARER2;

   911 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   912 		}

   913 	return KErrNone;

   914 	}

   915 

   916 TInt CSmsMessagingDMmTsy::NotifyMoSmsBearerChangeCancel(const TTsyReqHandle aTsyReqHandle)

   917 	{

   918 	LOGTEXT(_L8("CSmsMessagingDMmTsy::NotifyMoSmsBearerChangeCancel called"));

   919 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   920 	ReqCompleted(aTsyReqHandle,KErrCancel);

   921 	return KErrNone;

   922 	}

   923 

   924 /**************************************************************************/

   925 //

   926 //	CBroadcastMessagingDMmTsy

   927 //

   928 /**************************************************************************/

   929 

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

   931 	{

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

   933 	CleanupStack::PushL(subsession);

   934 	subsession->ConstructL();

   935 	CleanupStack::Pop();

   936 	return subsession;

   937 	}

   938 

   939 void CBroadcastMessagingDMmTsy::Init()

   940 	{}

   941 

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

   943 	:CSubSessionExtDummyBase(aFac), iPhone(aPhone), iCbmiListRequests(NULL)

   944 	{

   945 	iMessagingName=aName;

   946 	}

   947 

   948 void CBroadcastMessagingDMmTsy::ConstructL()

   949 	{

   950 	LOGTEXT(_L8("CBroadcastMessagingDMmTsy created"));

   951 	iCbmiListRequests = new (ELeave) CArrayPtrFlat<CListReadAllAttempt>(16);

   952 	}

   953 

   954 CBroadcastMessagingDMmTsy::~CBroadcastMessagingDMmTsy()

   955 	{

   956 	LOGTEXT(_L8("CBroadcastMessagingDMmTsy destroyed"));

   957 	iCbmiListRequests->ResetAndDestroy();

   958 	delete iCbmiListRequests;

   959 	}

   960 

   961 CTelObject* CBroadcastMessagingDMmTsy::OpenNewObjectByNameL(const TDesC& /*aName*/)

   962 	{

   963 	// Broadcast related stores can be opened from a Broadcast messaging sub-session

   964 

   965 

   966 	return NULL;

   967 	}

   968 

   969 CTelObject* CBroadcastMessagingDMmTsy::OpenNewObjectL(TDes&)

   970 	{

   971 	User::Leave(KErrNotSupported);

   972 	return NULL;

   973 	}

   974 

   975 CTelObject::TReqMode CBroadcastMessagingDMmTsy::ReqModeL(const TInt aIpc)

   976 	{

   977 	CTelObject::TReqMode ret=0;

   978 	switch (aIpc)

   979 		{

   980 //

   981 // Non-Flow Controlled Services

   982 //

   983 	case EMobileBroadcastMessagingGetFilterSetting:

   984 	case EMobileBroadcastMessagingGetCaps:

   985 	case EMobileBroadcastMessagingGetLanguageFilter:

   986 	case EMobileBroadcastMessagingSetLanguageFilter:

   987 	case EMobileBroadcastMessagingGetIdListPhase1:

   988 	case EMobileBroadcastMessagingGetIdListPhase2:

   989 	case EMobileBroadcastMessagingStoreIdList:

   990 		break;

   991 

   992 //

   993 // Flow Controlled Services

   994 //

   995 	case EMobileBroadcastMessagingSetFilterSetting:

   996 		ret=KReqModeFlowControlObeyed;

   997 		break;

   998 

   999 //

  1000 // Multiple Completion Services with Immediate Server Repost

  1001 // (Usually Notifications)

  1002 //

  1003 	case EMobileBroadcastMessagingReceiveMessage:

  1004 	case EMobileBroadcastMessagingNotifyFilterSettingChange:

  1005 	case EMobileBroadcastMessagingNotifyLanguageFilterChange:

  1006 	case EMobileBroadcastMessagingNotifyIdListChange:

  1007 		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

  1008 		break;

  1009 //

  1010 // Cancel Requests

  1011 //	

  1012 	case EMobileBroadcastMessagingReceiveMessageCancel:

  1013 	case EMobileBroadcastMessagingNotifyFilterSettingChangeCancel:

  1014 	case EMobileBroadcastMessagingSetFilterSettingCancel:

  1015 	case EMobileBroadcastMessagingGetLanguageFilterCancel:

  1016 	case EMobileBroadcastMessagingSetLanguageFilterCancel:

  1017 	case EMobileBroadcastMessagingNotifyLanguageFilterChangeCancel:

  1018 	case EMobileBroadcastMessagingGetIdListCancel:

  1019 	case EMobileBroadcastMessagingStoreIdListCancel:

  1020 	case EMobileBroadcastMessagingNotifyIdListChangeCancel:

  1021 	default:

  1022 		User::Leave(KErrNotSupported);

  1023 		break;

  1024 		}

  1025 

  1026 	return ret;

  1027 	}

  1028 

  1029 TInt CBroadcastMessagingDMmTsy::RegisterNotification(const TInt aIpc)

  1030 	{

  1031 	switch (aIpc)

  1032 		{

  1033 	case EMobileBroadcastMessagingReceiveMessage:

  1034 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Receive Message"));

  1035 		return KErrNone;

  1036 	case EMobileBroadcastMessagingNotifyFilterSettingChange:

  1037 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Receive setting Change "));

  1038 		return KErrNone;

  1039 	case EMobileBroadcastMessagingNotifyLanguageFilterChange:

  1040 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: RegisterNotification - Language Filter Change "));

  1041 		return KErrNone;

  1042 	case EMobileBroadcastMessagingNotifyIdListChange:

  1043 		LOGTEXT(_L8("CSmsMessagingDMmTsy: RegisterNotification - Notify BroadcastId List Change"));

  1044 		return KErrNone;

  1045 	default:

  1046 		// Unknown or invalid IPC

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

  1048 		return KErrNotSupported;

  1049 		}

  1050 	}

  1051 

  1052 TInt CBroadcastMessagingDMmTsy::DeregisterNotification(const TInt aIpc)

  1053 	{

  1054 	switch (aIpc)

  1055 		{

  1056 	case EMobileBroadcastMessagingReceiveMessage:

  1057 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Receive Message"));

  1058 		return KErrNone;

  1059 	case EMobileBroadcastMessagingNotifyFilterSettingChange:

  1060 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Receive setting Change "));

  1061 		return KErrNone;

  1062 	case EMobileBroadcastMessagingNotifyLanguageFilterChange:

  1063 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: DeregisterNotification - Language Filter Change "));

  1064 		return KErrNone;

  1065 	case EMobileBroadcastMessagingNotifyIdListChange:

  1066 		LOGTEXT(_L8("CSmsMessagingDMmTsy: DeregisterNotification - Notify BroadcastId List Change"));

  1067 		return KErrNone;

  1068 	default:

  1069 		// Unknown or invalid IPC

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

  1071 		return KErrNotSupported;

  1072 		}

  1073 	}

  1074 

  1075 TInt CBroadcastMessagingDMmTsy::NumberOfSlotsL(const TInt aIpc)

  1076 	{

  1077 	TInt numberOfSlots=1;

  1078 	switch (aIpc)

  1079 		{

  1080 	case EMobileBroadcastMessagingReceiveMessage:

  1081 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Registered with 10 slots"));

  1082 		numberOfSlots=10;

  1083 		break;

  1084 	case EMobileBroadcastMessagingNotifyFilterSettingChange:

  1085 	case EMobileBroadcastMessagingNotifyLanguageFilterChange:

  1086 	case EMobileBroadcastMessagingNotifyIdListChange:

  1087 		LOGTEXT(_L8("CBroadcastMessagingDMmTsy: Registered with 2 slots"));

  1088 		numberOfSlots=2;

  1089 		break;

  1090 	default:

  1091 		// Unknown or invalid Phone IPC

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

  1093 		User::Leave(KErrNotSupported);

  1094 		break;

  1095 		}

  1096 	return numberOfSlots;

  1097 	}

  1098 

  1099 

  1100 TInt CBroadcastMessagingDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

  1101 							  const TDataPackage& aPackage)

  1102 	{

  1103 	TInt err;

  1104 	TAny* dataPtr=aPackage.Ptr1();

  1105 	TAny* dataPtr2=aPackage.Ptr2();

  1106 

  1107 	switch (aIpc)

  1108 		{

  1109 	case EMobileBroadcastMessagingGetCaps:

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

  1111 

  1112 	case EMobileBroadcastMessagingGetFilterSetting:

  1113 		return GetFilterSetting(aTsyReqHandle,

  1114 			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));

  1115 	

  1116 	case EMobileBroadcastMessagingSetFilterSetting:

  1117 		return SetFilterSetting(aTsyReqHandle,

  1118 			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));

  1119 

  1120 	case EMobileBroadcastMessagingNotifyFilterSettingChange:

  1121 		return NotifyFilterSettingChange(aTsyReqHandle,

  1122 			REINTERPRET_CAST(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*, dataPtr));

  1123 	

  1124 	case EMobileBroadcastMessagingReceiveMessage:

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

  1126 	

  1127 	case EMobileBroadcastMessagingGetLanguageFilter:

  1128 		return GetLanguageFilter(aTsyReqHandle, aPackage.Des1u());

  1129 

  1130 	case EMobileBroadcastMessagingNotifyLanguageFilterChange:

  1131 		return NotifyLanguageFilterChange(aTsyReqHandle, aPackage.Des1u());

  1132 

  1133 	case EMobileBroadcastMessagingSetLanguageFilter:

  1134 		return SetLanguageFilter(aTsyReqHandle, aPackage.Des1u());

  1135