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 CListReadAllAttempt* CListReadAllAttempt::NewL(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)

    24 	{

    25 	CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);

    26 	CleanupStack::PushL(read);

    27 	read->ConstructL();

    28 	CleanupStack::Pop();

    29 	return read;

    30 	}

    31 

    32 CListReadAllAttempt::CListReadAllAttempt(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)

    33 	:CBase()

    34 	{

    35 	iClient.iSessionHandle=aId->iSessionHandle;

    36 	iClient.iSubSessionHandle=aId->iSubSessionHandle;

    37 	iReqHandle=aReqHandle;

    38 	iListBuf = NULL;

    39 	}

    40 

    41 void CListReadAllAttempt::ConstructL()

    42 	{

    43 	}

    44 

    45 CListReadAllAttempt::~CListReadAllAttempt()

    46 	{

    47 	delete iListBuf;

    48 	}

    49 

    50 /**************************************************************************/

    51 //

    52 //	CSmsStoreDMmTsy

    53 //

    54 /**************************************************************************/

    55 

    56 CSmsStoreDMmTsy* CSmsStoreDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,

    57 									   const TDesC& aName)

    58 	{

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

    60 	CleanupStack::PushL(subsession);

    61 	subsession->ConstructL();

    62 	CleanupStack::Pop();

    63 	return subsession;

    64 	}

    65 

    66 void CSmsStoreDMmTsy::Init()

    67 	{}

    68 

    69 CSmsStoreDMmTsy::CSmsStoreDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,

    70 								 const TDesC& aName)

    71 	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)

    72 	{

    73 	iSmsStoreName=aName;

    74 	}

    75 

    76 void CSmsStoreDMmTsy::ConstructL()

    77 	{

    78 	iSmsReadAll = new CArrayPtrFlat<CListReadAllAttempt>(1);

    79 	LOGTEXT(_L8("CSmsStoreDMmTsy created"));

    80 	}

    81 

    82 CSmsStoreDMmTsy::~CSmsStoreDMmTsy()

    83 	{

    84 	for (TInt i=iSmsReadAll->Count()-1; i>=0; --i)

    85 		{

    86 		CListReadAllAttempt* ptr=iSmsReadAll->At(i);

    87 		iSmsReadAll->Delete(i);

    88 		delete ptr;

    89 		}

    90 	delete iSmsReadAll;

    91 	LOGTEXT(_L8("CSmsStoreDMmTsy destroyed"));

    92 	}

    93 

    94 CTelObject* CSmsStoreDMmTsy::OpenNewObjectByNameL(const TDesC&)

    95 	{

    96 	User::Leave(KErrNotSupported);

    97 	return NULL;

    98 	}

    99 

   100 CTelObject* CSmsStoreDMmTsy::OpenNewObjectL(TDes&)

   101 	{

   102 	User::Leave(KErrNotSupported);

   103 	return NULL;

   104 	}

   105 

   106 CTelObject::TReqMode CSmsStoreDMmTsy::ReqModeL(const TInt aIpc)

   107 	{

   108 	CTelObject::TReqMode ret=0;

   109 	switch (aIpc)

   110 		{

   111 

   112 //

   113 // Normal Services

   114 //

   115 

   116 //

   117 // Flow Controlled Services

   118 //

   119 	case EMobilePhoneStoreRead:

   120 	case EMobilePhoneStoreWrite:

   121 	case EMobilePhoneStoreDelete:

   122 	case EMobilePhoneStoreDeleteAll:

   123 	case EMobilePhoneStoreReadAllPhase1:

   124 	case EMobilePhoneStoreReadAllPhase2:

   125 	case EMobilePhoneStoreGetInfo:

   126 		ret=KReqModeFlowControlObeyed;

   127 		break;

   128 

   129 //

   130 // Multiple Completion Services with Immediate Server Repost

   131 // (Usually Notifications)

   132 //

   133 	case EMobilePhoneStoreNotifyStoreEvent:

   134 		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   135 		break;

   136 //

   137 // Cancel Requests

   138 //

   139 	case EMobilePhoneStoreGetInfoCancel:

   140 	case EMobilePhoneStoreReadCancel:

   141 	case EMobilePhoneStoreWriteCancel:

   142 	case EMobilePhoneStoreDeleteCancel:

   143 	case EMobilePhoneStoreDeleteAllCancel:

   144 	case EMobilePhoneStoreReadAllCancel:

   145 	case EMobilePhoneStoreNotifyStoreEventCancel:

   146 	default:

   147 		User::Leave(KErrNotSupported);

   148 		break;

   149 		}

   150 	return ret;

   151 	}

   152 

   153 TInt CSmsStoreDMmTsy::RegisterNotification(const TInt aIpc)

   154 	{

   155 	switch (aIpc)

   156 		{

   157 	case EMobilePhoneStoreNotifyStoreEvent:

   158 		LOGTEXT(_L8("CSmsStoreDMmTsy: RegisterNotification - Store Event "));

   159 		return KErrNone;

   160 	default:

   161 		// Unknown or invalid IPC

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

   163 		return KErrNotSupported;

   164 		}

   165 	}

   166 

   167 TInt CSmsStoreDMmTsy::DeregisterNotification(const TInt aIpc)

   168 	{

   169 	switch (aIpc)

   170 		{

   171 	case EMobilePhoneStoreNotifyStoreEvent:

   172 		LOGTEXT(_L8("CSmsStoreDMmTsy: DeregisterNotification - Store Event "));

   173 		return KErrNone;

   174 	default:

   175 		// Unknown or invalid IPC

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

   177 		return KErrNotSupported;

   178 		}

   179 	}

   180 

   181 TInt CSmsStoreDMmTsy::NumberOfSlotsL(const TInt aIpc)

   182 	{

   183 	TInt numberOfSlots=1;

   184 	switch (aIpc)

   185 		{

   186 	case EMobilePhoneStoreNotifyStoreEvent:

   187 		LOGTEXT(_L8("CSmsStoreDMmTsy: Registered with 10 slots"));

   188 		numberOfSlots=10;

   189 		break;

   190 	default:

   191 		// Unknown or invalid Phone IPC

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

   193 		User::Leave(KErrNotSupported);

   194 		break;

   195 		}

   196 	return numberOfSlots;

   197 	}

   198 

   199 

   200 TInt CSmsStoreDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

   201 							  const TDataPackage& aPackage)

   202 	{

   203 	TAny* dataPtr=aPackage.Ptr1();

   204 	TAny* dataPtr2=aPackage.Ptr2();

   205 

   206 	switch (aIpc)

   207 		{

   208 	case EMobilePhoneStoreRead:

   209 		return Read(aTsyReqHandle, aPackage.Des1n());

   210 

   211 	case EMobilePhoneStoreWrite:

   212 		return Write(aTsyReqHandle, aPackage.Des1n());

   213 

   214 	case EMobilePhoneStoreDelete:

   215 		return Delete(aTsyReqHandle,

   216 			REINTERPRET_CAST(TInt*,dataPtr));

   217 

   218 	case EMobilePhoneStoreDeleteAll:

   219 		return DeleteAll(aTsyReqHandle);

   220 

   221 	case EMobilePhoneStoreGetInfo:

   222 		return GetInfo(aTsyReqHandle,

   223 			REINTERPRET_CAST(RMobilePhoneStore::TMobilePhoneStoreInfoV1*, dataPtr));

   224 

   225 	case EMobilePhoneStoreReadAllPhase1:

   226 		return ReadAllPhase1(aTsyReqHandle,

   227 			REINTERPRET_CAST(CRetrieveMobilePhoneSmsList::TBatchRequestData*,dataPtr),

   228 			REINTERPRET_CAST(TInt*,dataPtr2));

   229 

   230 	case EMobilePhoneStoreReadAllPhase2:

   231 		return ReadAllPhase2(aTsyReqHandle,

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

   233 

   234 	case EMobilePhoneStoreNotifyStoreEvent:

   235 		return NotifyStoreEvent(aTsyReqHandle,

   236 			REINTERPRET_CAST(RMobilePhoneStore::TMobileStoreEvent*,dataPtr),

   237 			REINTERPRET_CAST(TInt*,dataPtr2));

   238 

   239 	default:

   240 		return KErrNotSupported;

   241 		}

   242 	}

   243 

   244 TInt CSmsStoreDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   245 	{

   246 	switch (aIpc)

   247 		{

   248 	case EMobilePhoneStoreGetInfo:

   249 		return GetInfoCancel(aTsyReqHandle);

   250 	case EMobilePhoneStoreRead:

   251 		return ReadCancel(aTsyReqHandle);

   252 	case EMobilePhoneStoreWrite:

   253 		return WriteCancel(aTsyReqHandle);

   254 	case EMobilePhoneStoreDelete:

   255 		return DeleteCancel(aTsyReqHandle);

   256 	case EMobilePhoneStoreDeleteAll:

   257 		return DeleteAllCancel(aTsyReqHandle);

   258 	case EMobilePhoneStoreReadAllPhase1:

   259 	case EMobilePhoneStoreReadAllPhase2:

   260 		return ReadAllCancel(aTsyReqHandle);

   261 	case EMobilePhoneStoreNotifyStoreEvent:

   262 		return NotifyStoreEventCancel(aTsyReqHandle);

   263 		}

   264 	return KErrGeneral;

   265 	}

   266 

   267 

   268 TInt CSmsStoreDMmTsy::Read(const TTsyReqHandle aTsyReqHandle, TDes8* aEntry)

   269 	{

   270 	LOGTEXT(_L8("CSmsStoreDMmTsy::Read called"));

   271 

   272 	RMobileSmsStore::TMobileGsmSmsEntryV1Pckg* entryPckg = (RMobileSmsStore::TMobileGsmSmsEntryV1Pckg*)aEntry;

   273 	RMobileSmsStore::TMobileGsmSmsEntryV1& entry = (*entryPckg)();

   274 

   275 	if (entry.iIndex!=DMMTSY_SMS_STORE_INDEX1)

   276 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   277 	else

   278 		{

   279 		entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

   280 		entry.iMsgStatus =DMMTSY_SMS_STORE_STATUS1;

   281 		entry.iServiceCentre.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

   282 		entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

   283 		entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

   284 

   285 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   286 		}

   287 	return KErrNone;

   288 	}

   289 

   290 TInt CSmsStoreDMmTsy::ReadCancel(const TTsyReqHandle aTsyReqHandle)

   291 	{

   292 	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadCancel called"));

   293 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   294 	ReqCompleted(aTsyReqHandle,KErrCancel);

   295 	return KErrNone;

   296 	}

   297 

   298 TInt CSmsStoreDMmTsy::Write(const TTsyReqHandle aTsyReqHandle, TDesC8* aEntry)

   299 	{

   300 	LOGTEXT(_L8("CSmsStoreDMmTsy::Write called"));

   301 

   302 	RMobileSmsStore::TMobileCdmaSmsEntryV1Pckg* entryPckg = (RMobileSmsStore::TMobileCdmaSmsEntryV1Pckg*)aEntry;

   303 	RMobileSmsStore::TMobileCdmaSmsEntryV1& entry = (*entryPckg)();

   304 

   305 	if ((entry.iIndex != DMMTSY_SMS_STORE_INDEX2) ||

   306 		(entry.iMsgData.Compare(DMMTSY_SMS_MESSAGE_PDU2) != 0) ||

   307 		(entry.iMsgStatus != DMMTSY_SMS_STORE_STATUS2) ||

   308 		(entry.iRemoteParty.iTelNumber != DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER2) ||

   309 		(entry.iTeleservice != DMMTSY_SMS_MESSAGE_TELESERVICE))

   310 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   311 	else

   312 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   313 

   314 	return KErrNone;

   315 	}

   316 

   317 TInt CSmsStoreDMmTsy::WriteCancel(const TTsyReqHandle aTsyReqHandle)

   318 	{

   319 	LOGTEXT(_L8("CSmsStoreDMmTsy::WriteCancel called"));

   320 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   321 	ReqCompleted(aTsyReqHandle,KErrCancel);

   322 	return KErrNone;

   323 	}

   324 

   325 TInt CSmsStoreDMmTsy::Delete(const TTsyReqHandle aTsyReqHandle, TInt* aIndex)

   326 	{

   327 	LOGTEXT(_L8("CSmsStoreDMmTsy::Delete called"));

   328 	if (*aIndex!=DMMTSY_SMS_STORE_INDEX3)

   329 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   330 	else

   331 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   332 	return KErrNone;

   333 	}

   334 

   335 TInt CSmsStoreDMmTsy::DeleteCancel(const TTsyReqHandle aTsyReqHandle)

   336 	{

   337 	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteCancel called"));

   338 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   339 	ReqCompleted(aTsyReqHandle,KErrCancel);

   340 	return KErrNone;

   341 	}

   342 

   343 TInt CSmsStoreDMmTsy::DeleteAll(const TTsyReqHandle aTsyReqHandle)

   344 	{

   345 	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteAll called"));

   346 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   347 	return KErrNone;

   348 	}

   349 

   350 TInt CSmsStoreDMmTsy::DeleteAllCancel(const TTsyReqHandle aTsyReqHandle)

   351 	{

   352 	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteAllCancel called"));

   353 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   354 	ReqCompleted(aTsyReqHandle,KErrCancel);

   355 	return KErrNone;

   356 	}

   357 

   358 TInt CSmsStoreDMmTsy::GetInfo(const TTsyReqHandle aTsyReqHandle, RMobilePhoneStore::TMobilePhoneStoreInfoV1* aInfo)

   359 	{

   360 	LOGTEXT(_L8("CSmsStoreDMmTsy::GetInfo called"));

   361 

   362 	aInfo->iName=DMMTSY_MESSAGE_STORE_NAME;

   363 	aInfo->iType=DMMTSY_MESSAGE_STORE_TYPE;

   364 	aInfo->iTotalEntries=DMMTSY_MESSAGE_STORE_TOTAL_ENTRIES;

   365 	aInfo->iUsedEntries=DMMTSY_MESSAGE_STORE_USED_ENTRIES;

   366 	aInfo->iCaps=DMMTSY_MESSAGE_STORE_CAPS;

   367 

   368 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   369 	return KErrNone;

   370 	}

   371 

   372 TInt CSmsStoreDMmTsy::GetInfoCancel(const TTsyReqHandle aTsyReqHandle)

   373 	{

   374 	LOGTEXT(_L8("CSmsStoreDMmTsy::GetInfoCancel called"));

   375 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   376 	ReqCompleted(aTsyReqHandle,KErrCancel);

   377 	return KErrNone;

   378 	}

   379 

   380 TInt CSmsStoreDMmTsy::NotifyStoreEvent(const TTsyReqHandle aTsyReqHandle,

   381 									   RMobilePhoneStore::TMobileStoreEvent *aEvent,

   382 									   TInt* aIndex)

   383 	{

   384 	if (!iNotifyStoreEvent++)

   385 		{

   386 		LOGTEXT(_L8("CSmsStoreDMmTsy::NotifyStoreEvent called"));

   387 		*aIndex=DMMTSY_SMS_STORE_INDEX4;

   388 		*aEvent=DMMTSY_MESSAGE_STORE_EVENT;

   389 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   390 		}

   391 	return KErrNone;

   392 	}

   393 

   394 TInt CSmsStoreDMmTsy::NotifyStoreEventCancel(const TTsyReqHandle aTsyReqHandle)

   395 	{

   396 	LOGTEXT(_L8("CSmsStoreDMmTsy::NotifyStoreEventCancel called"));

   397 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   398 	ReqCompleted(aTsyReqHandle,KErrCancel);

   399 	return KErrNone;

   400 	}

   401 

   402 TInt CSmsStoreDMmTsy::ReadAllPhase1(const TTsyReqHandle aTsyReqHandle, CRetrieveMobilePhoneSmsList::TBatchRequestData* aRequest, TInt* aBufSize)

   403 	{

   404 	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadAllPhase1 called"));

   405 	TInt ret=KErrNone;

   406 	TInt leaveCode=KErrNone;

   407 

   408 	if (aRequest->iBatchRequest)

   409 		if ((aRequest->iBatchSize != DMMTSY_SMS_STORE_BATCH) ||

   410 		    (aRequest->iStartIndex != DMMTSY_SMS_STORE_START))

   411 			leaveCode = KErrCorrupt;

   412 

   413 	if (leaveCode == KErrNone)

   414 		{

   415 		if (aRequest->iEntryType==DMMTSY_SMS_STORE_GSMENTRY_TYPE)

   416 			{

   417 			TRAP(leaveCode, ret=ProcessReadAllGsmPhase1L(aTsyReqHandle, &aRequest->iClient, aBufSize););

   418 			}

   419 		else

   420 			{

   421 			TRAP(leaveCode, ret=ProcessReadAllCdmaPhase1L(aTsyReqHandle, &aRequest->iClient, aBufSize););

   422 			}

   423 		}

   424 

   425 	if (leaveCode != KErrNone)

   426 		ReqCompleted(aTsyReqHandle,leaveCode);

   427 

   428 	return ret;

   429 	};

   430 

   431 TInt CSmsStoreDMmTsy::ProcessReadAllGsmPhase1L(const TTsyReqHandle aTsyReqHandle,

   432 											   RMobilePhone::TClientId* aId,

   433 											   TInt* aBufSize)

   434 	{

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

   436 	CMobilePhoneGsmSmsList* list=CMobilePhoneGsmSmsList::NewL();

   437 	CleanupStack::PushL(list);

   438 

   439 	RMobileSmsStore::TMobileGsmSmsEntryV1 entry;

   440 

   441 	// fill up an example list

   442 	for (TInt index=0; index < DMMTSY_SMS_STORE_COUNT; index++)

   443 		{

   444 		switch (index)

   445 			{

   446 		case 0:

   447 			entry.iIndex = DMMTSY_SMS_STORE_INDEX1;

   448 			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

   449 			entry.iServiceCentre.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

   450 			entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

   451 			entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

   452 			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS1;

   453 			break;

   454 		case 1:

   455 			entry.iIndex = DMMTSY_SMS_STORE_INDEX2;

   456 			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU2;

   457 			entry.iServiceCentre.iTelNumber = DMMTSY_SMSP_STORE_SCA;

   458 			entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

   459 			entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

   460 			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS2;

   461 			break;

   462 		case 2:

   463 			// No need to recopy other info parameters

   464 			// as they are identical to the ones in case 1 for this test

   465 			entry.iIndex=DMMTSY_SMS_STORE_INDEX3;

   466 			break;

   467 		case 3:

   468 		default:

   469 			// No need to recopy other info parameters

   470 			// as they are identical to the ones in case 1 for this test

   471 			entry.iIndex=DMMTSY_SMS_STORE_INDEX4;

   472 			break;

   473 			}

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

   475 			list->AddEntryL(entry);

   476 		}

   477 

   478 	// Store the streamed list and the client ID

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

   480 	CleanupStack::PushL(read);

   481 

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

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

   484 

   485 	iSmsReadAll->AppendL(read);

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

   487 

   488 	// return the CBufFlat’s size to client

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

   490 

   491 	// Complete first phase of list retrieval

   492 	iPhone->AddDelayedReq(aTsyReqHandle,this);

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

   494 	return KErrNone;

   495 	}

   496 

   497 

   498 TInt CSmsStoreDMmTsy::ProcessReadAllCdmaPhase1L(const TTsyReqHandle aTsyReqHandle,

   499 											   RMobilePhone::TClientId* aId,

   500 											   TInt* aBufSize)

   501 	{

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

   503 	CMobilePhoneCdmaSmsList* list=CMobilePhoneCdmaSmsList::NewL();

   504 	CleanupStack::PushL(list);

   505 

   506 	RMobileSmsStore::TMobileCdmaSmsEntryV1 entry;

   507 

   508 	// fill up an example list

   509 	for (TInt index=0; index < DMMTSY_SMS_STORE_COUNT; index++)

   510 		{

   511 		switch (index)

   512 			{

   513 		case 0:

   514 			entry.iIndex = DMMTSY_SMS_STORE_INDEX1;

   515 			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

   516 			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS1;

   517 			entry.iRemoteParty.iTelNumber = DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER1;

   518 			entry.iTeleservice = DMMTSY_SMS_MESSAGE_TELESERVICE;

   519 			break;

   520 		case 1:

   521 			entry.iIndex = DMMTSY_SMS_STORE_INDEX2;

   522 			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU2;

   523 			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS2;

   524 			break;

   525 		case 2:

   526 			// No need to recopy other info parameters

   527 			// as they are identical to the ones in case 1 for this test

   528 			entry.iIndex=DMMTSY_SMS_STORE_INDEX3;

   529 			break;

   530 		case 3:

   531 		default:

   532 			// No need to recopy other info parameters

   533 			// as they are identical to the ones in case 1 for this test

   534 			entry.iIndex=DMMTSY_SMS_STORE_INDEX4;

   535 			break;

   536 			}

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

   538 			list->AddEntryL(entry);

   539 		}

   540 

   541 	// Store the streamed list and the client ID

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

   543 	CleanupStack::PushL(read);

   544 

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

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

   547 

   548 	iSmsReadAll->AppendL(read);

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

   550 

   551 	// return the CBufFlat’s size to client

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

   553 

   554 	// Complete first phase of list retrieval

   555 	iPhone->AddDelayedReq(aTsyReqHandle,this);

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

   557 	return KErrNone;

   558 	}

   559 

   560 

   561 TInt CSmsStoreDMmTsy::ReadAllPhase2(TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aId, TDes8* aBuffer)

   562 	{

   563 	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadAllPhase2 called"));

   564 	CListReadAllAttempt* read=NULL;

   565 	// Find the read attempt from this client

   566 	for (TInt i=0; i<iSmsReadAll->Count(); ++i)

   567 		{

   568 		read = iSmsReadAll->At(i);

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

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

   571 			{

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

   573 			// Copy the streamed list to the client

   574 			aBuffer->Copy(bufPtr);

   575 			delete read;

   576 			iSmsReadAll->Delete(i);

   577 			ReqCompleted(aTsyReqHandle,KErrNone);

   578 			return KErrNone;

   579 			}

   580 		}

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

   582 	return KErrNotFound;

   583 	}

   584 

   585 TInt CSmsStoreDMmTsy::ReadAllCancel(const TTsyReqHandle aTsyReqHandle)

   586 	{

   587 	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadAllCancel called"));

   588 

   589 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   590 

   591 	// Remove the read all attempt from iSmsReadAll

   592 	CListReadAllAttempt* read=NULL;

   593 	for (TInt i=0; i<iSmsReadAll->Count(); ++i)

   594 		{

   595 		read = iSmsReadAll->At(i);

   596 		if (read->iReqHandle == aTsyReqHandle)

   597 			{

   598 			delete read;

   599 			iSmsReadAll->Delete(i);

   600 			break;

   601 			}

   602 		}

   603 

   604 	ReqCompleted(aTsyReqHandle,KErrCancel);

   605 	return KErrNone;

   606 	}

   607 

   608 /**************************************************************************/

   609 //

   610 //	CNamStoreDMmTsy

   611 //

   612 /**************************************************************************/

   613 

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

   615 	{

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

   617 	CleanupStack::PushL(subsession);

   618 	subsession->ConstructL();

   619 	CleanupStack::Pop();

   620 	return subsession;

   621 	}

   622 

   623 void CNamStoreDMmTsy::Init()

   624 	{}

   625 

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

   627 	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)

   628 	{

   629 	iNamStoreName=aName;

   630 	}

   631 

   632 void CNamStoreDMmTsy::ConstructL()

   633 	{

   634 	iNamReadAll = new CArrayPtrFlat<CListReadAllAttempt>(1);

   635 	LOGTEXT(_L8("CNamStoreDMmTsy created"));

   636 	}

   637 

   638 CNamStoreDMmTsy::~CNamStoreDMmTsy()

   639 	{

   640 	for (TInt i=iNamReadAll->Count()-1; i>=0; --i)

   641 		{

   642 		CListReadAllAttempt* ptr=iNamReadAll->At(i);

   643 		iNamReadAll->Delete(i);

   644 		delete ptr;

   645 		}

   646 	delete iNamReadAll;

   647 	LOGTEXT(_L8("CNamStoreDMmTsy destroyed"));

   648 	}

   649 

   650 CTelObject* CNamStoreDMmTsy::OpenNewObjectByNameL(const TDesC&)

   651 	{

   652 	User::Leave(KErrNotSupported);

   653 	return NULL;

   654 	}

   655 

   656 CTelObject* CNamStoreDMmTsy::OpenNewObjectL(TDes&)

   657 	{

   658 	User::Leave(KErrNotSupported);

   659 	return NULL;

   660 	}

   661 

   662 CTelObject::TReqMode CNamStoreDMmTsy::ReqModeL(const TInt aIpc)

   663 	{

   664 	CTelObject::TReqMode ret=0;

   665 	switch (aIpc)

   666 		{

   667 

   668 	case EMobileNamStoreSetActiveNam:

   669 		break;

   670 

   671 //

   672 // Flow Controlled Services

   673 //

   674 	case EMobilePhoneStoreRead:

   675 	case EMobilePhoneStoreWrite:

   676 	case EMobilePhoneStoreDelete:

   677 	case EMobilePhoneStoreDeleteAll:

   678 	case EMobilePhoneStoreReadAllPhase1:

   679 	case EMobilePhoneStoreReadAllPhase2:

   680 	case EMobilePhoneStoreReadAllV4Phase1:

   681 	case EMobilePhoneStoreReadAllV4Phase2:

   682 	case EMobilePhoneStoreGetInfo:

   683 	case EMobileNamStoreStoreAll:

   684 	case EMobileNamStoreStoreAllV4:

   685 		ret=KReqModeFlowControlObeyed;

   686 		break;

   687 //

   688 // Multiple Completion Services with Immediate Server Repost

   689 // (Usually Notifications)

   690 //

   691 	case EMobilePhoneStoreNotifyStoreEvent:

   692 		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   693 		break;

   694 //

   695 // Cancel Requests

   696 //

   697 	case EMobilePhoneStoreGetInfoCancel:

   698 	case EMobilePhoneStoreReadCancel:

   699 	case EMobilePhoneStoreWriteCancel:

   700 	case EMobilePhoneStoreDeleteCancel:

   701 	case EMobilePhoneStoreDeleteAllCancel:

   702 	case EMobilePhoneStoreReadAllCancel:

   703 	case EMobilePhoneStoreNotifyStoreEventCancel:

   704 	case EMobileNamStoreStoreAllCancel:

   705 	case EMobileNamStoreStoreAllV4Cancel:

   706 	default:

   707 		User::Leave(KErrNotSupported);

   708 		break;

   709 		}

   710 	return ret;

   711 	}

   712 

   713 TInt CNamStoreDMmTsy::RegisterNotification(const TInt aIpc)

   714 	{

   715 	switch (aIpc)

   716 		{

   717 	case EMobilePhoneStoreNotifyStoreEvent:

   718 		LOGTEXT(_L8("CNamStoreDMmTsy: RegisterNotification - Store Event "));

   719 		return KErrNone;

   720 	default:

   721 		// Unknown or invalid IPC

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

   723 		return KErrNotSupported;

   724 		}

   725 	}

   726 

   727 TInt CNamStoreDMmTsy::DeregisterNotification(const TInt aIpc)

   728 	{

   729 	switch (aIpc)

   730 		{

   731 	case EMobilePhoneStoreNotifyStoreEvent:

   732 		LOGTEXT(_L8("CNamStoreDMmTsy: DeregisterNotification - Store Event "));

   733 		return KErrNone;

   734 	default:

   735 		// Unknown or invalid IPC

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

   737 		return KErrNotSupported;

   738 		}

   739 	}

   740 

   741 TInt CNamStoreDMmTsy::NumberOfSlotsL(const TInt aIpc)

   742 	{

   743 	TInt numberOfSlots=1;

   744 	switch (aIpc)

   745 		{

   746 	case EMobilePhoneStoreNotifyStoreEvent:

   747 		LOGTEXT(_L8("CNamStoreDMmTsy: Registered with 2 slot"));

   748 		numberOfSlots=2;

   749 		break;

   750 	default:

   751 		// Unknown or invalid Phone IPC

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

   753 		User::Leave(KErrNotSupported);

   754 		break;

   755 		}

   756 	return numberOfSlots;

   757 	}

   758 

   759 

   760 TInt CNamStoreDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

   761 							  const TDataPackage& aPackage)

   762 	{

   763 	TAny* dataPtr=aPackage.Ptr1();

   764 	TAny* dataPtr2=aPackage.Ptr2();

   765 

   766 	switch (aIpc)

   767 		{

   768 	case EMobilePhoneStoreRead:

   769 		return Read(aTsyReqHandle, aPackage.Des1n());

   770 

   771 	case EMobilePhoneStoreWrite:

   772 		return Write(aTsyReqHandle, aPackage.Des1n());

   773 

   774 	case EMobilePhoneStoreDelete:

   775 		return Delete(aTsyReqHandle,

   776 			REINTERPRET_CAST(TInt*,dataPtr));

   777 

   778 	case EMobilePhoneStoreDeleteAll:

   779 		return DeleteAll(aTsyReqHandle);

   780 

   781 	case EMobilePhoneStoreGetInfo:

   782 		return GetInfo(aTsyReqHandle,

   783 			REINTERPRET_CAST(RMobileNamStore::TMobileNamStoreInfoV1*, dataPtr));

   784 

   785 	case EMobilePhoneStoreReadAllPhase1:

   786 		return ReadAllPhase1(aTsyReqHandle,

   787 			REINTERPRET_CAST(CRetrieveMobilePhoneNamList::TNamRequestData*,dataPtr),

   788 			REINTERPRET_CAST(TInt*,dataPtr2));

   789 

   790 	case EMobilePhoneStoreReadAllPhase2:

   791 		return ReadAllPhase2(aTsyReqHandle,

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

   793 

   794 	case EMobilePhoneStoreReadAllV4Phase1:

   795 		return ReadAllPhase1V4(aTsyReqHandle,

   796 			REINTERPRET_CAST(CRetrieveMobilePhoneNamList::TNamRequestData*,dataPtr),

   797 			REINTERPRET_CAST(TInt*,dataPtr2));

   798 

   799 	case EMobilePhoneStoreReadAllV4Phase2:

   800 		return ReadAllPhase2V4(aTsyReqHandle,

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

   802 

   803 	case EMobilePhoneStoreNotifyStoreEvent:

   804 		return NotifyStoreEvent(aTsyReqHandle,

   805 			REINTERPRET_CAST(RMobilePhoneStore::TMobileStoreEvent*,dataPtr),

   806 			REINTERPRET_CAST(TInt*,dataPtr2));

   807 

   808 	case EMobileNamStoreSetActiveNam:

   809 		return SetActiveNam(aTsyReqHandle,

   810 				REINTERPRET_CAST(TInt*,dataPtr));

   811 

   812 	case EMobileNamStoreStoreAll:

   813 		return StoreAll(aTsyReqHandle,REINTERPRET_CAST(TInt*,dataPtr),aPackage.Des2n());

   814 

   815 	case EMobileNamStoreStoreAllV4:

   816 		return StoreAllV4(aTsyReqHandle,REINTERPRET_CAST(TInt*,dataPtr),aPackage.Des2n());

   817 

   818 	default:

   819 		return KErrNotSupported;

   820 		}

   821 	}

   822 

   823 TInt CNamStoreDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   824 	{

   825 	switch (aIpc)

   826 		{

   827 	case EMobilePhoneStoreGetInfo:

   828 		return GetInfoCancel(aTsyReqHandle);

   829 	case EMobilePhoneStoreRead:

   830 		return ReadCancel(aTsyReqHandle);

   831 	case EMobilePhoneStoreWrite:

   832 		return WriteCancel(aTsyReqHandle);

   833 	case EMobilePhoneStoreDelete:

   834 		return DeleteCancel(aTsyReqHandle);

   835 	case EMobilePhoneStoreDeleteAll:

   836 		return DeleteAllCancel(aTsyReqHandle);

   837 	case EMobilePhoneStoreReadAllPhase1:

   838 	case EMobilePhoneStoreReadAllPhase2:

   839 	case EMobilePhoneStoreReadAllV4Phase1:

   840 	case EMobilePhoneStoreReadAllV4Phase2:

   841 		return ReadAllCancel(aTsyReqHandle);

   842 	case EMobilePhoneStoreNotifyStoreEvent:

   843 		return NotifyStoreEventCancel(aTsyReqHandle);

   844 	case EMobileNamStoreSetActiveNam:

   845 		return SetActiveNamCancel(aTsyReqHandle);

   846 	case EMobileNamStoreStoreAll:

   847 	case EMobileNamStoreStoreAllV4:

   848 		return StoreAllCancel(aTsyReqHandle);

   849 		}

   850 	return KErrGeneral;

   851 	}

   852 

   853 

   854 void CNamStoreDMmTsy::InitNamEntry(RMobileNamStore::TMobileNamEntryV1& aEntry)

   855 	{

   856 	aEntry.iNamId = DMMTSY_NAM_STORE_NAMID;

   857 	aEntry.iParamIdentifier = DMMTSY_NAM_STORE_PARAM;

   858 	aEntry.iData = DMMTSY_NAM_STORE_DATA;

   859 	}

   860 

   861 TInt CNamStoreDMmTsy::ValidateNamEntry(RMobileNamStore::TMobileNamEntryV1& aEntry)

   862 	{

   863 	if ((aEntry.iNamId != DMMTSY_NAM_STORE_NAMID) ||

   864 		(aEntry.iParamIdentifier != DMMTSY_NAM_STORE_PARAM) ||

   865 		(aEntry.iData.Compare(DMMTSY_NAM_STORE_DATA) != 0))

   866 		return KErrCorrupt;

   867 	else

   868 		return KErrNone;

   869 	}

   870 

   871 void CNamStoreDMmTsy::InitNamEntry(RMobileNamStore::TMobileNamEntryV4& aEntry)

   872 	{

   873 	aEntry.iNamId = DMMTSY_NAM_STORE_NAMID;

   874 	aEntry.iParamIdentifier = DMMTSY_NAM_STORE_PARAM;

   875 	aEntry.iData = DMMTSY_NAM_STORE_DATA_V4;

   876 	}

   877 

   878 TInt CNamStoreDMmTsy::ValidateNamEntry(RMobileNamStore::TMobileNamEntryV4& aEntry)

   879 	{

   880 	if ((aEntry.iNamId != DMMTSY_NAM_STORE_NAMID) ||

   881 		(aEntry.iParamIdentifier != DMMTSY_NAM_STORE_PARAM) ||

   882 		(aEntry.iData.Compare(DMMTSY_NAM_STORE_DATA_V4) != 0))

   883 		return KErrCorrupt;

   884 	else

   885 		return KErrNone;

   886 	}

   887 

   888 TInt CNamStoreDMmTsy::Read(const TTsyReqHandle aTsyReqHandle, TDes8* aEntry)

   889 	{

   890 	LOGTEXT(_L8("CNamStoreDMmTsy::Read called"));

   891 	RMobileNamStore::TMobileNamEntryV1Pckg* entryPckg = (RMobileNamStore::TMobileNamEntryV1Pckg*)aEntry;

   892 	RMobileNamStore::TMobileNamEntryV4Pckg* entryV4Pckg = (RMobileNamStore::TMobileNamEntryV4Pckg*)aEntry;

   893 

   894 	RMobilePhone::TMultimodeType& entry = (*entryPckg)();

   895 	RMobileNamStore::TMobileNamEntryV1& entryV1 = (*entryPckg)();

   896 	RMobileNamStore::TMobileNamEntryV4& entryV4 = (*entryV4Pckg)();

   897 

   898 	if(entry.ExtensionId() == KETelExtMultimodeV1)

   899 		{

   900 		if (entryV1.iIndex!=DMMTSY_NAM_STORE_INDEX1)

   901 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   902 		else

   903 			{

   904 			InitNamEntry(entryV1);

   905 			iPhone->AddDelayedReq(aTsyReqHandle,this);

   906 			}

   907 		}

   908 	else if(entry.ExtensionId() == KETelExtMultimodeV4)

   909 		{

   910 		if (entryV4.iIndex!=DMMTSY_NAM_STORE_INDEX1)

   911 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   912 		else

   913 			{

   914 			InitNamEntry(entryV4);

   915 			iPhone->AddDelayedReq(aTsyReqHandle,this);

   916 			}

   917 		}

   918 	else

   919 		{

   920 		// if not multimode v1 or v4, there is a problem

   921 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   922 		}

   923 

   924 	return KErrNone;

   925 	}

   926 

   927 TInt CNamStoreDMmTsy::ReadCancel(const TTsyReqHandle aTsyReqHandle)

   928 	{

   929 	LOGTEXT(_L8("CNamStoreDMmTsy::ReadCancel called"));

   930 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   931 	ReqCompleted(aTsyReqHandle,KErrCancel);

   932 	return KErrNone;

   933 	}

   934 

   935 TInt CNamStoreDMmTsy::Write(const TTsyReqHandle aTsyReqHandle, TDesC8* aEntry)

   936 	{

   937 	LOGTEXT(_L8("CNamStoreDMmTsy::Write called"));

   938 	RMobileNamStore::TMobileNamEntryV1Pckg* entryPckg = (RMobileNamStore::TMobileNamEntryV1Pckg*)aEntry;

   939 	RMobileNamStore::TMobileNamEntryV4Pckg* entryV4Pckg = (RMobileNamStore::TMobileNamEntryV4Pckg*)aEntry;

   940 

   941 	RMobilePhone::TMultimodeType& entry = (*entryPckg)();

   942 	RMobileNamStore::TMobileNamEntryV1& entryV1 = (*entryPckg)();

   943 	RMobileNamStore::TMobileNamEntryV4& entryV4 = (*entryV4Pckg)();

   944 

   945 	if(entry.ExtensionId() == KETelExtMultimodeV1)

   946 		{

   947 		if ((entryV1.iIndex!=DMMTSY_NAM_STORE_INDEX2) || (ValidateNamEntry(entryV1) != KErrNone))

   948 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   949 		else

   950 			iPhone->AddDelayedReq(aTsyReqHandle,this);

   951 		}

   952 	else if(entry.ExtensionId() == KETelExtMultimodeV4)

   953 		{

   954 		if ((entryV4.iIndex!=DMMTSY_NAM_STORE_INDEX2) || (ValidateNamEntry(entryV4) != KErrNone))

   955 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   956 		else

   957 			{

   958 			iPhone->AddDelayedReq(aTsyReqHandle,this);

   959 			}

   960 		}

   961 	else

   962 		{

   963 		// if not multimode v1 or v4, there is a problem

   964 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   965 		}

   966 	return KErrNone;

   967 	}

   968 

   969 TInt CNamStoreDMmTsy::WriteCancel(const TTsyReqHandle aTsyReqHandle)

   970 	{

   971 	LOGTEXT(_L8("CNamStoreDMmTsy::WriteCancel called"));

   972 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   973 	ReqCompleted(aTsyReqHandle,KErrCancel);

   974 	return KErrNone;

   975 	}

   976 

   977 TInt CNamStoreDMmTsy::Delete(const TTsyReqHandle aTsyReqHandle, TInt* aIndex)

   978 	{

   979 	LOGTEXT(_L8("CNamStoreDMmTsy::Delete called"));

   980 	if (*aIndex!=DMMTSY_NAM_STORE_INDEX1)

   981 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   982 	else

   983 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   984 	return KErrNone;

   985 	}

   986 

   987 TInt CNamStoreDMmTsy::DeleteCancel(const TTsyReqHandle aTsyReqHandle)

   988 	{

   989 	LOGTEXT(_L8("CNamStoreDMmTsy::DeleteCancel called"));

   990 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   991 	ReqCompleted(aTsyReqHandle,KErrCancel);

   992 	return KErrNone;

   993 	}

   994 

   995 TInt CNamStoreDMmTsy::DeleteAll(const TTsyReqHandle aTsyReqHandle)

   996 	{

   997 	LOGTEXT(_L8("CNamStoreDMmTsy::DeleteAll called"));

   998 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   999 	return KErrNone;

  1000 	}

  1001 

  1002 TInt CNamStoreDMmTsy::DeleteAllCancel(const TTsyReqHandle aTsyReqHandle)

  1003 	{

  1004 	LOGTEXT(_L8("CNamStoreDMmTsy::DeleteAllCancel called"));

  1005 	iPhone->RemoveDelayedReq(aTsyReqHandle);

  1006 	ReqCompleted(aTsyReqHandle,KErrCancel);

  1007 	return KErrNone;

  1008 	}

  1009 

  1010 TInt CNamStoreDMmTsy::GetInfo(const TTsyReqHandle aTsyReqHandle, RMobileNamStore::TMobileNamStoreInfoV1* aInfo)

  1011 	{

  1012 	LOGTEXT(_L8("CNamStoreDMmTsy::GetInfo called"));

  1013 	aInfo->iName=DMMTSY_NAM_STORE_NAME;

  1014 	aInfo->iType=DMMTSY_NAM_STORE_TYPE;

  1015 	aInfo->iTotalEntries=DMMTSY_NAM_STORE_ENTRIES;

  1016 	aInfo->iUsedEntries=DMMTSY_NAM_STORE_USED;

  1017 	aInfo->iCaps=DMMTSY_NAM_STORE_CAPS;

  1018 	aInfo->iNamCount = DMMTSY_NAM_STORE_COUNT;

  1019 	aInfo->iActiveNam = DMMTSY_NAM_STORE_ACTIVE;

  1020 	iPhone->AddDelayedReq(aTsyReqHandle,this);

  1021 

  1022 	return KErrNone;

  1023 	}

  1024 

  1025 TInt CNamStoreDMmTsy::GetInfoCancel(const TTsyReqHandle aTsyReqHandle)

  1026 	{

  1027 	LOGTEXT(_L8("CNamStoreDMmTsy::GetInfoCancel called"));

  1028 	iPhone->RemoveDelayedReq(aTsyReqHandle);

  1029 	ReqCompleted(aTsyReqHandle,KErrCancel);

  1030 	return KErrNone;

  1031 	}

  1032 

  1033 TInt CNamStoreDMmTsy::NotifyStoreEvent(const TTsyReqHandle aTsyReqHandle,

  1034 									   RMobilePhoneStore::TMobileStoreEvent *aEvent,

  1035 									   TInt* aIndex)

  1036 	{

  1037 	if (!iNotifyStoreEvent++)

  1038 		{

  1039 		LOGTEXT(_L8("CNamStoreDMmTsy::NotifyStoreEvent called"));

  1040 		*aIndex=DMMTSY_NAM_STORE_INDEX2;

  1041 		*aEvent = DMMTSY_NAM_STORE_EVENT;

  1042 		iPhone->AddDelayedReq(aTsyReqHandle,this);

  1043 		}

  1044 	return KErrNone;

  1045 	}

  1046 

  1047 TInt CNamStoreDMmTsy::NotifyStoreEventCancel(const TTsyReqHandle aTsyReqHandle)

  1048 	{

  1049 	LOGTEXT(_L8("CNamStoreDMmTsy::NotifyStoreEventCancel called"));

  1050 	iPhone->RemoveDelayedReq(aTsyReqHandle);

  1051 	ReqCompleted(aTsyReqHandle,KErrCancel);

  1052 	return KErrNone;

  1053 	}

  1054 

  1055 TInt CNamStoreDMmTsy::ReadAllPhase1(const TTsyReqHandle aTsyReqHandle, CRetrieveMobilePhoneNamList::TNamRequestData* aRequestData, TInt* aBufSize)

  1056 	{

  1057 	LOGTEXT(_L8("CNamStoreDMmTsy::ReadAllPhase1 called"));

  1058 	TInt ret=KErrNone;

  1059 	TInt leaveCode=KErrNone;

  1060 	if (aRequestData->iNamId != DMMTSY_NAM_STORE_NAMID)

  1061 		leaveCode = KErrCorrupt;

  1062 	else

  1063 		{

  1064 		TRAP(leaveCode, ret=ProcessReadAllPhase1L(aTsyReqHandle, &aRequestData->iClient, aBufSize););

  1065 		}

  1066 	if (leaveCode != KErrNone)

  1067 		ReqCompleted(aTsyReqHandle,leaveCode);

  1068 	return ret;

  1069 	};

  1070 

  1071 TInt CNamStoreDMmTsy::ReadAllPhase1V4(const TTsyReqHandle aTsyReqHandle, CRetrieveMobilePhoneNamList::TNamRequestData* aRequestData, TInt* aBufSize)

  1072 	{

  1073 	LOGTEXT(_L8("CNamStoreDMmTsy::ReadAllPhase1V4 called"));

  1074 	TInt ret=KErrNone;

  1075 	TInt leaveCode=KErrNone;

  1076 	if (aRequestData->iNamId != DMMTSY_NAM_STORE_NAMID)

  1077 		leaveCode = KErrCorrupt;

  1078 	else

  1079 		{

  1080 		TRAP(leaveCode, ret=ProcessReadAllPhase1V4L(aTsyReqHandle, &aRequestData->iClient, aBufSize););

  1081 		}

  1082 	if (leaveCode != KErrNone)

  1083 		ReqCompleted(aTsyReqHandle,leaveCode);

  1084 	return ret;

  1085 	};

  1086 

  1087 TInt CNamStoreDMmTsy::ProcessReadAllPhase1L(const TTsyReqHandle aTsyReqHandle,

  1088 											 RMobilePhone::TClientId* aId,

  1089 											 TInt* aBufSize)

  1090 	{

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

  1092 	CMobilePhoneNamList* list=CMobilePhoneNamList::NewL();

  1093 	CleanupStack::PushL(list);

  1094 

  1095 	RMobileNamStore::TMobileNamEntryV1 entry;

  1096 

  1097 	// fill up an example list

  1098 	for (TInt index=0; index < DMMTSY_NAM_STORE_COUNT; index++)

  1099 		{

  1100 		switch (index)

  1101 			{

  1102 		case 0:

  1103 			InitNamEntry(entry);

  1104 			entry.iIndex=DMMTSY_NAM_STORE_INDEX1;

  1105 			break;

  1106 		case 1:

  1107 			InitNamEntry(entry);

  1108 			entry.iIndex=DMMTSY_NAM_STORE_INDEX2;

  1109 		default:

  1110 			break;

  1111 			}

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

  1113 			list->AddEntryL(entry);

  1114 		}

  1115 

  1116 	// Store the streamed list and the client ID

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

  1118 	CleanupStack::PushL(read);

  1119 

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

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

  1122 

  1123 	iNamReadAll->AppendL(read);

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

  1125 

  1126 	// return the CBufFlat’s size to client

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

  1128 

  1129 	// Complete first phase of list retrieval

  1130 	iPhone->AddDelayedReq(aTsyReqHandle,this);

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

  1132 	return KErrNone;

  1133 	}

  1134 

  1135 TInt CNamStoreDMmTsy::ProcessReadAllPhase1V4L(const TTsyReqHandle aTsyReqHandle,