1 // Copyright (c) 1998-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 #ifdef _DEBUG

    17 #undef _NO_SESSION_LOGGING_

    18 #endif

    19 

    20 #include <s32std.h>

    21 #include <txtrich.h>

    22 #include "MSVIDS.H"

    23 #include "MSVUIDS.H"

    24 

    25 #include "MSVAPI.H"

    26 #include "MSVCOP.H"

    27 #include "MCLENTRY.H"

    28 #include "MSVPANIC.H"

    29 #include "MSVUTILS.H"

    30 

    31 #include <mmsvstoremanager.h>

    32 

    33 const TInt KMsvClientEntryArrayGranuality=8;

    34 const TInt KMsvEntryObserverArrayGranuality=4;

    35 const TInt KMsvMtmListGranularity=8;

    36 

    37 //**********************************

    38 // CMsvClientEntry

    39 //**********************************

    40 

    41 // static 

    42 CMsvClientEntry* CMsvClientEntry::NewLC(const TMsvEntry& aEntry, TMsvClientEntryType aType)

    43 	{

    44 	CMsvClientEntry* self = new(ELeave) CMsvClientEntry(aEntry, aType);

    45 	CleanupStack::PushL(self);

    46 	self->ConstructL();

    47 	return self;

    48 	}

    49 

    50 

    51 CMsvClientEntry::CMsvClientEntry(const TMsvEntry& aEntry, TMsvClientEntryType aType)

    52 :iEntry(aEntry), iType(aType)

    53 	{

    54 	__DECLARE_NAME(_S("CMsvClientEntry"));

    55 	}

    56 

    57 

    58 CMsvClientEntry::~CMsvClientEntry()

    59 	{

    60 	delete iDescription;

    61 	delete iDetails;

    62 	}

    63 

    64 void CMsvClientEntry::ConstructL()

    65 	{

    66 	iDescription = HBufC::NewL(iEntry.iDescription.Length());

    67 	iDescription->Des().Copy(iEntry.iDescription);

    68 	iEntry.iDescription.Set(iDescription->Des());

    69 	iDetails = HBufC::NewL(iEntry.iDetails.Length());

    70 	iDetails->Des().Copy(iEntry.iDetails);

    71 	iEntry.iDetails.Set(iDetails->Des());

    72 	}

    73 

    74 

    75 

    76 

    77 //**********************************

    78 // CMsvEntry

    79 //**********************************

    80 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

    81 

    82 EXPORT_C CMsvEntry* CMsvEntry::NewL(CMsvSession& aMsvSession, TMsvId aMsvId, const TMsvSelectionOrdering& aOrdering, TBool aChildrenOfAvailableDrives)

    83 /** Creates a new CMsvEntry for the specified entry ID. 

    84 

    85 Note that this function does not create a new entry, but simply a new object 

    86 to access an existing entry. To create a new entry, use CreateL().

    87 

    88 @param aMsvSession The client’s Message Server session 

    89 @param aMsvId ID of the entry to access 

    90 @param aSortType  The initial sort order of children of the entry, for example, 

    91 when returned by ChildrenL(). The order can be changed later by SetSortTypeL().

    92 @param aChildrenOfAvailableDrives Indicates whether children from all available drives are 

    93 to be fetched during construction of this entry. However, a value of true is valid only

    94 if aMsvId is one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted.

    95 

    96 @return If the function succeeds, this is a pointer to a newly allocated and initialised object. 

    97 @leave KErrNotFound The requested entry does not exist.

    98 @leave KErrNoMemory A memory allocation failed.

    99 @leave KErrArgument aChildrenOfAvailableDrives is set to true and the requested entry is not 

   100 one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted.

   101 */

   102     {

   103     CMsvEntry* self = new(ELeave) CMsvEntry(aMsvSession, aOrdering, aChildrenOfAvailableDrives);

   104     CleanupStack::PushL(self);

   105     self->ConstructL(aMsvId);

   106     CleanupStack::Pop();

   107     return self;

   108     }

   109 

   110 

   111 CMsvEntry::CMsvEntry(CMsvSession& aMsvSession, const TMsvSelectionOrdering& aOrdering, TBool aChildrenOfAvailableDrives)

   112 :iState(EValid), iMsvSession(aMsvSession), iOrdering(aOrdering), iChildrenOfAvailableDrives(aChildrenOfAvailableDrives)

   113     {

   114     __DECLARE_NAME(_S("CMsvEntry"));

   115     }

   116 

   117 

   118 EXPORT_C void CMsvEntry::SetStandardFolderEntryL(TMsvId aId)

   119 //

   120 // Changes the context to another entry

   121 // If the function leaves, the context is unchanged

   122 //

   123 /** Sets the context to the specified entry while also fetching

   124 children from all available drives. This function can be used to

   125 set the context to only the standard folders i.e. Inbox, Outbox,

   126 Drafts, Sent or Deleted.

   127 

   128 If the function leaves, the context is unchanged.

   129 

   130 @param aId ID of the message entry which is to become the new context 

   131 @leave KErrNotFound aId could not be found in the index.

   132 @leave KErrArgument aId is not one of the standard folders, i.e. Inbox,

   133 Outbox, Drafts, Sent or Deleted folders.

   134 */

   135     {

   136     __ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

   137 

   138     if (aId==iEntryPtr->Id() && iState==EValid)

   139         return;

   140     

   141     SetEntryNoCheckL(aId, ETrue);

   142     }

   143 

   144 

   145 

   146 #endif           // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   147 

   148 

   149 EXPORT_C CMsvEntry* CMsvEntry::NewL(CMsvSession& aMsvSession, TMsvId aMsvId, const TMsvSelectionOrdering& aOrdering)

   150 //

   151 //

   152 //

   153 /** Creates a new CMsvEntry for the specified entry ID. 

   154 

   155 Note that this function does not create a new entry, but simply a new object 

   156 to access an existing entry. To create a new entry, use CreateL().

   157 

   158 @param aMsvSession The client’s Message Server session 

   159 @param aMsvId ID of the entry to access 

   160 @param aSortType  The initial sort order of children of the entry, for example, 

   161 when returned by ChildrenL(). The order can be changed later by SetSortTypeL(). 

   162 @return If the function succeeds, this is a pointer to a newly allocated and initialised object. 

   163 @leave KErrNotFound The requested entry does not exist 

   164 @leave KErrNoMemory A memory allocation failed 

   165 */

   166 	{

   167 	CMsvEntry* self = new(ELeave) CMsvEntry(aMsvSession, aOrdering);

   168 	CleanupStack::PushL(self);

   169 	self->ConstructL(aMsvId);

   170 	CleanupStack::Pop();

   171 	return self;

   172 	}

   173 

   174 

   175 CMsvEntry::CMsvEntry(CMsvSession& aMsvSession, const TMsvSelectionOrdering& aOrdering)

   176 :iState(EValid), iMsvSession(aMsvSession), iOrdering(aOrdering)

   177 //

   178 //

   179 //

   180 	{

   181 	__DECLARE_NAME(_S("CMsvEntry"));

   182 	}

   183 

   184 

   185 EXPORT_C CMsvEntry::~CMsvEntry()

   186 //

   187 //

   188 //

   189 /** Destructor. 

   190 

   191 This cleans up the object. CMsvEntry objects must be deleted by client applications 

   192 when they are no longer required. Note that deleting a CMsvEntry object does 

   193 not delete the context, simply the immediate means of accessing it. */

   194 	{

   195 	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpenOnDestruction2));

   196 

   197 	if (iOberserverAdded)

   198 		iMsvSession.RemoveObserver(*this);

   199 

   200 	if (iEntries)

   201 		iEntries->ResetAndDestroy();

   202 

   203 	delete iEntries;

   204 	delete iSortedChildren;

   205 	delete iObservers;

   206 	delete iMtmList;

   207 	}

   208 

   209 void CMsvEntry::ConstructL(TMsvId aId)

   210 //

   211 //

   212 //

   213 	{

   214 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   215     if(iChildrenOfAvailableDrives && !MsvUtils::IsStandardId(aId))

   216         {

   217         User::Leave(KErrArgument);

   218         }

   219 #endif

   220 	iEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);

   221 	iMtmList = new(ELeave) CArrayFixFlat<TUid>(KMsvMtmListGranularity);

   222 	iSortedChildren = CMsvEntryArray::NewL(*iMtmList);

   223 

   224 	// get the required entry from the server

   225 	CMsvClientEntry* cEntry = DoGetEntryLC(aId, iOwningService);

   226 	cEntry->SetType(EMsvClientContext);

   227 	iEntries->AppendL(cEntry);

   228 	CleanupStack::Pop(); // cEntry

   229 	iEntryPtr = &iEntries->At(0)->Entry();

   230 

   231 	// get the children

   232 	DoGetChildrenL();

   233 

   234 	// Get the notification sequence number

   235 	iNotifySequence = iMsvSession.Session().NotifySequenceL();

   236 

   237 	// get the event notifications from the server

   238 	iMsvSession.AddObserverL(*this);

   239 	iOberserverAdded=ETrue;

   240 

   241 #ifndef _NO_SESSION_LOGGING_

   242 	Log(_L("Constructed CMsvEntry on entry %x"), aId); 

   243 #endif

   244 	}

   245 

   246 #ifndef _NO_SESSION_LOGGING_

   247 void CMsvEntry::Log(TRefByValue<const TDesC> aFmt, ...)

   248 	{

   249 	VA_LIST list;

   250 	VA_START(list, aFmt);

   251 

   252 	// Generate the text

   253 	TBuf<256> buf;

   254 	buf.FormatList(aFmt, list);

   255 

   256 	// Write to file

   257 	_LIT(KFormatFile, "CMsvEntry %x: %S");

   258 	iMsvSession.iLog.WriteFormat(KFormatFile, this, &buf);

   259 

   260 	// Write to serial

   261 #ifndef _NO_SESSION_LOGGING_SERIAL_

   262 	_LIT(KFormatSerial, "MSGS: CMsvEntry %x: %S");

   263 	RDebug::Print(KFormatSerial, this, &buf);

   264 #endif

   265 	}

   266 #endif

   267 

   268 CMsvClientEntry* CMsvEntry::DoGetEntryLC(TMsvId aId, TMsvId& aOwningService)

   269 //

   270 // Gets the entry data from the server and create a CMsvClientEntry around it

   271 //

   272 	{

   273 	TMsvEntry tEntry;

   274 	User::LeaveIfError(iMsvSession.Session().GetEntry(aId, aOwningService, tEntry));

   275 	if (tEntry.iType==KUidMsvRootEntry)

   276 		aOwningService=aId;

   277 	return CMsvClientEntry::NewLC(tEntry, EMsvClientNull);

   278 	}

   279 

   280 

   281 

   282 void CMsvEntry::DoGetChildrenL()

   283 //

   284 // Gets the children of the context and places them in the entries array

   285 // The sorted children pointer array is implicited sorted, as the entries are retrieved

   286 // from the server with the current sort order

   287 //

   288 	{

   289 	__ASSERT_DEBUG(iEntries->Count()==1, PanicServer(EMsvChildEntriesExist1));

   290 	__ASSERT_DEBUG(iSortedChildren->Count()==0, PanicServer(EMsvChildEntriesExist2));

   291 

   292 	// get the children from the server - using only the visible flag

   293 	TMsvSelectionOrdering order(KMsvNoGrouping, EMsvSortByNone, iOrdering.ShowInvisibleEntries());

   294 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   295     // If child entries from all drives in the device are to be fetched.

   296     if(iChildrenOfAvailableDrives)

   297         {

   298 		User::LeaveIfError(iMsvSession.Session().GetChildrenAll(iEntryPtr->Id(), *iEntries, order));

   299 		}

   300 	else

   301 #endif

   302         {

   303         User::LeaveIfError(iMsvSession.Session().GetChildren(iEntryPtr->Id(), *iEntries, order));

   304 		}

   305 	

   306 	// add the children to the sorted pointer list - current context is the first entry

   307 	TInt totalCount=iEntries->Count();

   308 	for (TInt count=1; count<totalCount; count++)

   309 		iSortedChildren->AppendL(&iEntries->At(count)->Entry());

   310 

   311 	// sort the children

   312 	iSortedChildren->SortL(iOrdering);

   313 	}

   314 

   315 

   316 EXPORT_C void CMsvEntry::SetEntryL(TMsvId aId)

   317 //

   318 // Changes the context to another entry

   319 // If the function leaves, the context is unchanged

   320 //

   321 /** Sets the context to the specified entry. 

   322 

   323 If the function leaves, the context is unchanged.

   324 

   325 @param aId ID of the message entry which is to become the new context 

   326 @leave KErrNotFound aId could not be found in the index */

   327 	{

   328 	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

   329 

   330 	if (aId==iEntryPtr->Id() && iState==EValid)

   331 		return;

   332 	

   333  	SetEntryNoCheckL(aId);

   334 	}

   335 

   336 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   337 EXPORT_C void CMsvEntry::SetEntryNoCheckL(TMsvId aId, TBool aChildrenOfAvailableDrives /* DEFAULT=EFalse*/)

   338 //

   339 // Changes the context to another entry

   340 // If the function leaves, the context is unchanged

   341 // The function does not check for when the context is already on

   342 // the given TMsvId.

   343 //

   344 /** Sets the context to the specified entry.

   345 Children from all available drives will be fetched depending on the value of

   346 aChildrenOfAvailableDrives.

   347 

   348 If the function leaves, the context is unchanged.

   349 

   350 @internalTechnology

   351 @param aId ID of the message entry which is to become the new context

   352 @param aChildrenOfAvailableDrives Indicates whether children from all available drives are to

   353 be fetched during construction of this entry. However, a value of true is valid only

   354 if aMsvId is one among TMsvId's of Inbox, Outbox, Drafts, Sent or Deleted folders.

   355 @leave KErrNotFound aMsvId could not be found in the index 

   356 @leave KErrArgument aChildrenOfAvailableDrives is set to true and the requested entry is not

   357 one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted. */

   358     {

   359     __ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

   360 

   361     if(aChildrenOfAvailableDrives && !MsvUtils::IsStandardId(aId))

   362         {

   363         User::Leave(KErrArgument);

   364         }

   365 

   366     // create new entry array

   367     CArrayPtrFlat<CMsvClientEntry>* newEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);

   368     CleanupStack::PushL(newEntries);

   369 

   370     // get the new context and place in array

   371     TMsvId newOwningService;

   372     CMsvClientEntry* cEntry = DoGetEntryLC(aId, newOwningService);

   373     cEntry->SetType(EMsvClientContext);

   374     newEntries->AppendL(cEntry);

   375     // create new children array

   376     CMsvEntryArray* newSortedChildren = CMsvEntryArray::NewL(*iMtmList);

   377 

   378     // keep the old arrays

   379     CArrayPtrFlat<CMsvClientEntry>* oldEntries = iEntries;

   380     CMsvEntryArray* oldSortedChildren = iSortedChildren;

   381 

   382     TBool oldFlag = iChildrenOfAvailableDrives;

   383     iChildrenOfAvailableDrives = aChildrenOfAvailableDrives;

   384 

   385     // use new arrays

   386     CleanupStack::Pop(2); // cEntry, newEntries

   387     iEntries = newEntries;

   388     iSortedChildren = newSortedChildren;

   389     iEntryPtr = &iEntries->At(0)->Entry();

   390 

   391     // get the children and sort accordingly

   392     TRAPD(leave, DoGetChildrenL(); iNotifySequence = iMsvSession.Session().NotifySequenceL());

   393 

   394     if (leave)

   395         {

   396 #ifndef _NO_SESSION_LOGGING_

   397         Log(_L("Failed to SetEntryL to %x with %d"), aId, leave); 

   398 #endif

   399 

   400         // reset the old context

   401         iChildrenOfAvailableDrives = oldFlag;

   402 

   403         iEntries = oldEntries;

   404         iSortedChildren = oldSortedChildren;

   405         iEntryPtr = &iEntries->At(0)->Entry();

   406         // cleanup

   407         newEntries->ResetAndDestroy();

   408         delete newEntries;

   409         delete newSortedChildren;

   410         // propogate leave

   411         User::Leave(leave);

   412         }

   413     else

   414         {

   415 #ifndef _NO_SESSION_LOGGING_

   416         Log(_L("SetEntryL to %x, sequence %d"), aId, iNotifySequence); 

   417 #endif

   418 

   419         // set the new owning service

   420         iOwningService = newOwningService;

   421         // delete the old context

   422         oldEntries->ResetAndDestroy();

   423         delete oldEntries;

   424         delete oldSortedChildren;

   425         // make sure the state is marked as valid

   426         iState = EValid;

   427         }

   428     }

   429 #else   //#define SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT

   430 

   431 EXPORT_C void CMsvEntry::SetEntryNoCheckL(TMsvId aId)

   432 //

   433 // Changes the context to another entry

   434 // If the function leaves, the context is unchanged

   435 // The function does not check for when the context is already on

   436 // the given TMsvId.

   437 //

   438 /** Sets the context to the specified entry. 

   439 

   440 If the function leaves, the context is unchanged.

   441 

   442 @internalTechnology

   443 @param aId ID of the message entry which is to become the new context 

   444 @leave KErrNotFound aMsvId could not be found in the index */

   445 	{

   446 	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

   447 

   448 	// create new entry array

   449 	CArrayPtrFlat<CMsvClientEntry>* newEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);

   450 	CleanupStack::PushL(newEntries);

   451 

   452 	// get the new context and place in array

   453 	TMsvId newOwningService;

   454 	CMsvClientEntry* cEntry = DoGetEntryLC(aId, newOwningService);

   455 	cEntry->SetType(EMsvClientContext);

   456 	newEntries->AppendL(cEntry);

   457 	// create new children array

   458 	CMsvEntryArray* newSortedChildren = CMsvEntryArray::NewL(*iMtmList);

   459 

   460 	// keep the old arrays

   461 	CArrayPtrFlat<CMsvClientEntry>* oldEntries = iEntries;

   462 	CMsvEntryArray* oldSortedChildren = iSortedChildren;

   463 

   464 	// use new arrays

   465 	CleanupStack::Pop(2); // cEntry, newEntries

   466 	iEntries = newEntries;

   467 	iSortedChildren = newSortedChildren;

   468 	iEntryPtr = &iEntries->At(0)->Entry();

   469 

   470 	// get the children and sort accordingly

   471 	TRAPD(leave, DoGetChildrenL(); iNotifySequence = iMsvSession.Session().NotifySequenceL());

   472 

   473 	if (leave)

   474 		{

   475 #ifndef _NO_SESSION_LOGGING_

   476 		Log(_L("Failed to SetEntryL to %x with %d"), aId, leave); 

   477 #endif

   478 

   479 		// reset the old context

   480 		iEntries = oldEntries;

   481 		iSortedChildren = oldSortedChildren;

   482 		iEntryPtr = &iEntries->At(0)->Entry();

   483 		// cleanup

   484 		newEntries->ResetAndDestroy();

   485 		delete newEntries;

   486 		delete newSortedChildren;

   487 		// propogate leave

   488 		User::Leave(leave);

   489 		}

   490 	else

   491 		{

   492 #ifndef _NO_SESSION_LOGGING_

   493 		Log(_L("SetEntryL to %x, sequence %d"), aId, iNotifySequence); 

   494 #endif

   495 

   496 		// set the new owning service

   497 		iOwningService = newOwningService;

   498 		// delete the old context

   499 		oldEntries->ResetAndDestroy();

   500 		delete oldEntries;

   501 		delete oldSortedChildren;

   502 		// make sure the state is marked as valid

   503 		iState = EValid;

   504 		}

   505 	}

   506 #endif

   507 /**

   508 Creates a new child entry owned by the context asynchronously.

   509 

   510 Note that all session observers are notified when a new entry is created with 

   511 an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 

   512 such session observers themselves. When the object receives such a session 

   513 notification, it calls all registered entry observers with a TMsvEntryEvent 

   514 event EMsvNewChildren, passing in the ID of the new child.

   515 

   516 If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .

   517 If aEntry is a service entry, then the context must be set to the root entry.

   518 

   519 The returned CMsvOperation object completes when creation is complete.

   520 

   521 @param	aEntry

   522 Index entry value for the new entry 

   523 

   524 @param	aStatus

   525 The request status to be completed when the operation has finished 

   526 

   527 @leave	KErrArgument aEntry is invalid 

   528 

   529 @return 

   530 The operation object controlling the create command. 

   531 */

   532 EXPORT_C CMsvOperation* CMsvEntry::CreateL(const TMsvEntry& aEntry, TRequestStatus& aStatus)

   533 	{

   534 	return CreateL(aEntry, RProcess().SecureId(), aStatus);

   535 	}

   536 	

   537 /**

   538 Creates a new child entry owned by the context asynchronously. Sets the owner of 

   539 the created entry to process specified by the supplied ID.

   540 

   541 Note that all session observers are notified when a new entry is created with 

   542 an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 

   543 such session observers themselves. When the object receives such a session 

   544 notification, it calls all registered entry observers with a TMsvEntryEvent 

   545 event EMsvNewChildren, passing in the ID of the new child.

   546 

   547 If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .

   548 If aEntry is a service entry, then the context must be set to the root entry.

   549 

   550 The returned CMsvOperation object completes when creation is complete.

   551 

   552 @param	aEntry

   553 Index entry value for the new entry 

   554 

   555 @param	aOwnerId

   556 The ID of process that owns the created entry.

   557 

   558 @param	aStatus

   559 The request status to be completed when the operation has finished 

   560 

   561 @leave 	KErrArgument aEntry is invalid 

   562 

   563 @return 

   564 The operation object controlling the create command. 

   565 */

   566 EXPORT_C CMsvOperation* CMsvEntry::CreateL(const TMsvEntry& aEntry, TSecureId aOwnerId, TRequestStatus& aStatus)

   567 	{

   568 #ifndef _NO_SESSION_LOGGING_

   569 	Log(_L("Asynchronous CreateL")); 

   570 #endif

   571 

   572 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

   573 

   574 	TMsvEntry entry=aEntry;

   575 	entry.SetParent(iEntryPtr->Id());

   576 

   577 	__ASSERT_DEBUG(MsvUtils::ValidEntry(entry, ETrue), PanicServer(EMsvCreatingInvalidEntry));

   578 	if (!MsvUtils::ValidEntry(entry, ETrue))

   579 		User::Leave(KErrArgument);

   580 

   581 	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);

   582 	CleanupStack::PushL(operation);

   583 	User::LeaveIfError(iMsvSession.Session().OperationMtmL(iEntryPtr->Id(), operation->iMtm, operation->iService));

   584 	iMsvSession.Session().CreateEntryL(entry, operation->Id(), aOwnerId, operation->iStatus);

   585 	operation->Start();

   586 	CleanupStack::Pop(); // operation

   587 	return operation;

   588 	}

   589 	

   590 

   591 /** 

   592 Creates a new child entry owned by the context synchronously. 

   593 

   594 Note that all session observers are notified when a new entry is created with 

   595 an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 

   596 such session observers themselves. When the object receives such a session 

   597 notification, it calls all registered entry observers with a TMsvEntryEvent 

   598 event EMsvNewChildren, passing in the ID of the new child.

   599 

   600 If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .

   601 If aEntry is a service entry, then the context must be set to the root entry.

   602 

   603 This function can only be used on local entries.

   604 

   605 @param	aEntry

   606 Index entry value for the new entry 

   607 

   608 @leave	KErrArgument aEntry is invalid

   609 */

   610 EXPORT_C void CMsvEntry::CreateL(TMsvEntry& aEntry)

   611 	{

   612 	CreateL(aEntry, RProcess().SecureId());

   613 	}

   614 	

   615 /** 

   616 Creates a new child entry owned by the context synchronously. Sets the owner of 

   617 the created entry to process specified by the supplied ID. 

   618 

   619 Note that all session observers are notified when a new entry is created with 

   620 an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 

   621 such session observers themselves. When the object receives such a session 

   622 notification, it calls all registered entry observers with a TMsvEntryEvent 

   623 event EMsvNewChildren, passing in the ID of the new child.

   624 

   625 If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .

   626 If aEntry is a service entry, then the context must be set to the root entry.

   627 

   628 This function can only be used on local entries.

   629 

   630 @param	aEntry

   631 Index entry value for the new entry

   632 

   633 @param	aOwnerId

   634 The ID of process that owns the created entry.

   635 

   636 @leave	KErrArgument aEntry is invalid

   637 */

   638 EXPORT_C void CMsvEntry::CreateL(TMsvEntry& aEntry, TSecureId aOwnerId)

   639 	{

   640 #ifndef _NO_SESSION_LOGGING_

   641 	Log(_L("Synchronous CreateL")); 

   642 #endif

   643 	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService));

   644 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

   645 

   646 	TMsvEntry entry=aEntry;

   647 	entry.SetParent(iEntryPtr->Id());

   648 

   649 	__ASSERT_DEBUG(MsvUtils::ValidEntry(entry, ETrue), PanicServer(EMsvCreatingInvalidEntry));

   650 	if (!MsvUtils::ValidEntry(entry, ETrue))

   651 		User::Leave(KErrArgument);

   652 

   653 	CMsvEntryArray* newSortedChildren = NULL;

   654 	CMsvClientEntry* cEntry = NULL;

   655 

   656 	TBool addEntry = entry.Visible() || iOrdering.ShowInvisibleEntries();

   657 	if (addEntry)

   658 		{

   659 		// Create what may be the new child entry if nothing goes wrong

   660 		cEntry = CMsvClientEntry::NewLC(entry, EMsvClientChild);

   661 

   662 		// Reserve space for the new entry for later

   663 		iEntries->SetReserveL(iEntries->Count() + 1);

   664 

   665 		newSortedChildren = CMsvEntryArray::NewLC(*iMtmList);

   666 

   667 		// add the children to the sorted pointer list - current context is the first entry

   668 		TInt totalCount=iEntries->Count();

   669 		for (TInt count=1; count<totalCount; count++)

   670 			newSortedChildren->AppendL(&iEntries->At(count)->Entry());

   671 

   672 		// We've created a new sorted child list now so we won't leave later

   673 		newSortedChildren->AppendL(&cEntry->Entry());

   674 		newSortedChildren->SortL(iOrdering);

   675 		}

   676 

   677 	TInt id = iMsvSession.OperationId();

   678 	iMsvSession.Session().CreateEntryL(entry, id, aOwnerId);

   679 	iMsvSession.CheckDrive();

   680 

   681     TPckgBuf<TMsvLocalOperationProgress> progressPack;

   682 	User::LeaveIfError(iMsvSession.Session().OperationCompletion(id, progressPack));

   683 	User::LeaveIfError(progressPack().iError);

   684 

   685 	// Can't leave after here

   686 

   687 	if (addEntry)

   688 		{

   689 		CleanupStack::Pop(); // newSortedChildren

   690 		delete iSortedChildren;

   691 		iSortedChildren = newSortedChildren;

   692 

   693 		CleanupStack::Pop(); // cEntry

   694 		iEntries->AppendL(cEntry); // Will not leave because we've reserved space earlier

   695 		cEntry->SetId(progressPack().iId);

   696 

   697 		TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);

   698 		ptr->SetOwner(ETrue);

   699 		}

   700 

   701 	aEntry.SetParent(iEntryPtr->Id());

   702 	aEntry.SetId(progressPack().iId);

   703 

   704 	// If the entry is a service its service Id is the same as its Id

   705 	// Otherwise it must be a local entry

   706 	// We don't allow synchronous creation of remote entries

   707 	TMsvId serviceId = aEntry.Id();

   708 

   709 	aEntry.iServiceId = (aEntry.iType == KUidMsvServiceEntry) ? serviceId : KMsvLocalServiceIndexEntryId;

   710 	}

   711 

   712 /** 

   713 Sets the context's index entry to the specified values. The returned CMsvOperation 

   714 object completes when the change is complete.

   715 

   716 It is important to note that the state of the context is undefined until the 

   717 observer of the entry has been informed that the entry has been changed, or 

   718 the operation is completed with an error. If the function leaves, the context 

   719 is unchanged.

   720 

   721 @param	aEntry 

   722 The new index entry values for the context

   723 

   724 @param	aStatus 

   725 The request status to be completed when the operation has finished 

   726 

   727 @leave KErrAccessDenied The entry is locked by another client 

   728 

   729 @leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 

   730 the same as the context ID 

   731 

   732 @leave KErrNoMemory The operation could not be created or passed to the server 

   733 

   734 @return

   735 An operation object controlling the change command

   736 */

   737 EXPORT_C CMsvOperation* CMsvEntry::ChangeL(const TMsvEntry& aEntry, TRequestStatus& aStatus)

   738 	{

   739 	return ChangeL(aEntry, RProcess().SecureId(), aStatus);

   740 	}

   741 

   742 /** 

   743 Sets the context's index entry to the specified values. The returned CMsvOperation 

   744 object completes when the change is complete. Sets the owner of the changed entry 

   745 to process specified by the supplied ID. 

   746 

   747 It is important to note that the state of the context is undefined until the 

   748 observer of the entry has been informed that the entry has been changed, or 

   749 the operation is completed with an error. If the function leaves, the context 

   750 is unchanged.

   751 

   752 @param	aEntry 

   753 The new index entry values for the context

   754 

   755 @param	aOwnerId

   756 The ID of process that owns the changed entry.

   757 

   758 @param	aStatus 

   759 The request status to be completed when the operation has finished 

   760 

   761 @leave KErrAccessDenied The entry is locked by another client 

   762 

   763 @leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 

   764 the same as the context ID 

   765 

   766 @leave KErrNoMemory The operation could not be created or passed to the server 

   767 

   768 @return

   769 An operation object controlling the change command

   770 */

   771 EXPORT_C CMsvOperation* CMsvEntry::ChangeL(const TMsvEntry& aEntry, TSecureId aOwnerId, TRequestStatus& aStatus)

   772 	{

   773 #ifndef _NO_SESSION_LOGGING_

   774 	Log(_L("Asynchronous ChangeL to %x"), aEntry.Id()); 

   775 #endif

   776 

   777 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext, PanicServer(EMsvEntryAlreadyChangingContext));

   778 	__ASSERT_DEBUG(aEntry.Id()==iEntryPtr->Id(), PanicServer(EMsvChangingEntryNotContext));

   779 	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvChangingToInvalidEntry));

   780 

   781 	// can only change the current context

   782 	if (aEntry.Id()!=iEntryPtr->Id() || aEntry.Parent()!=iEntryPtr->Parent() || !MsvUtils::ValidEntry(aEntry))

   783 		User::Leave(KErrArgument);

   784 

   785 	// cannot change standard folders

   786 	if (iEntryPtr->StandardFolder())

   787 		User::Leave(KErrAccessDenied);

   788 

   789 	// create the operation

   790 	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);

   791 	CleanupStack::PushL(operation);

   792 	if (iEntryPtr->iType==KUidMsvServiceEntry)

   793 		{

   794 		operation->iMtm = KUidMsvLocalServiceMtm;

   795 		operation->iService = KMsvLocalServiceIndexEntryId;

   796 		}

   797 	else

   798 		User::LeaveIfError(iMsvSession.Session().OperationMtmL(iEntryPtr->Id(), operation->iMtm, operation->iService));

   799 	

   800 	// check that no other entries are type EMsvClientChangedContext

   801 	TInt count=iEntries->Count();

   802 	while (count--)

   803 		{

   804 		if (iEntries->At(count)->Type() == EMsvClientChangedContext)

   805 			{

   806 			delete iEntries->At(count);

   807 			iEntries->Delete(count);

   808 			}

   809 		}

   810 

   811 	// create local copy of entry

   812 	TMsvEntry entry=aEntry;

   813 

   814 	// check the hidden flags are correct

   815 	entry.SetOwner(iEntryPtr->Owner());

   816 	entry.SetDeleted(iEntryPtr->Deleted());

   817 

   818 	// store the new context for after the operation has completed

   819 	CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(entry, EMsvClientChangedContext);

   820 	if (iEntries->Count()==1)

   821 		iEntries->AppendL(cEntry);

   822 	else

   823 		iEntries->InsertL(1, cEntry);

   824 

   825 	// start the change operation

   826 	TRAPD(leave, iMsvSession.Session().ChangeEntryL(entry, operation->Id(), aOwnerId, operation->iStatus)); 

   827 	if (leave)

   828 		{

   829 		iEntries->Delete(1);

   830 		CleanupStack::PopAndDestroy(); // operation	& cEntry

   831 		User::Leave(leave);

   832 		}

   833 

   834 	operation->Start();

   835 	iState = EInvalidChangingContext;

   836 	CleanupStack::Pop(2); // operation and cEntry

   837 	return operation;

   838 	}

   839 

   840 /** 

   841 Sets the context's index entry to the specified values. The function is performed 

   842 synchronously.

   843 

   844 This function can only be used on local entries.

   845 

   846 @param	aEntry 

   847 The new index entry values for the context 

   848 

   849 @leave KErrAccessDenied The entry is locked by another client 

   850 

   851 @leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 

   852 the same as the context ID 

   853 

   854 @leave KErrNoMemory The operation could not be created or passed to the server

   855 */

   856 EXPORT_C void CMsvEntry::ChangeL(const TMsvEntry& aEntry)

   857 	{

   858 	ChangeL(aEntry, RProcess().SecureId());

   859 	}

   860 

   861 /** 

   862 Sets the context's index entry to the specified values. The function is performed 

   863 synchronously. Sets the owner of the changed entry to process specified by the 

   864 supplied ID. 

   865 

   866 This function can only be used on local entries.

   867 

   868 @param	aEntry 

   869 The new index entry values for the context 

   870 

   871 @param	aOwnerId

   872 The ID of process that owns the changed entry.

   873 

   874 @leave KErrAccessDenied The entry is locked by another client 

   875 

   876 @leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 

   877 the same as the context ID 

   878 

   879 @leave KErrNoMemory The operation could not be created or passed to the server

   880 */

   881 EXPORT_C void CMsvEntry::ChangeL(const TMsvEntry& aEntry, TSecureId aOwnerId)

   882 	{

   883 #ifndef _NO_SESSION_LOGGING_

   884 	Log(_L("Synchronous ChangeL to %x"), aEntry.Id()); 

   885 #endif

   886 

   887 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext, PanicServer(EMsvEntryAlreadyChangingContext));

   888 	__ASSERT_DEBUG(aEntry.Id()==iEntryPtr->Id(), PanicServer(EMsvChangingEntryNotContext));

   889 	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvChangingToInvalidEntry));

   890 

   891 	// can only change the current context

   892 	if (aEntry.Id()!=iEntryPtr->Id() || aEntry.Parent()!=iEntryPtr->Parent() || !MsvUtils::ValidEntry(aEntry))

   893 		User::Leave(KErrArgument);

   894 

   895 	// cannot change standard folders

   896 	if (iEntryPtr->StandardFolder())

   897 		User::Leave(KErrAccessDenied);

   898 

   899 	// create local copy of entry

   900 	TMsvEntry entry=aEntry;

   901 

   902 	// check the hidden flags are correct

   903 	entry.SetOwner(iEntryPtr->Owner());

   904 	entry.SetDeleted(iEntryPtr->Deleted());

   905 

   906 	// store the new context for after the operation has completed

   907 	CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(entry, EMsvClientContext);

   908 

   909 	TInt id = iMsvSession.OperationId();

   910 	iMsvSession.Session().ChangeEntryL(aEntry, id, aOwnerId); 

   911 

   912     TPckgBuf<TMsvLocalOperationProgress> progressPack;

   913 	User::LeaveIfError(iMsvSession.Session().OperationCompletion(id, progressPack));

   914 	User::LeaveIfError(progressPack().iError);

   915 

   916 	// Cannot leave after this

   917 	delete iEntries->At(0);

   918 	CleanupStack::Pop(); // cEntry

   919 	iEntries->At(0) = cEntry;

   920 	iEntryPtr = &iEntries->At(0)->Entry();

   921 	}

   922 

   923 

   924 EXPORT_C CMsvOperation* CMsvEntry::DeleteL(TMsvId aId, TRequestStatus& aStatus)

   925 //

   926 // Deletes a child of the context

   927 //

   928 	/** Deletes a child entry of the context asynchronously.

   929 	

   930 	The delete works recursively through all the descendants. If a child or any 

   931 	descendant is locked by another client or any store or file is open, then 

   932 	that child will not be deleted. Any files and stores associated with the entry 

   933 	are deleted.

   934 	

   935 	The returned CMsvOperation object completes when deletion is complete.

   936 	

   937 	

   938 	@param aId ID of entry to be deleted 

   939 	@param aStatus The request status to be completed when the operation has finished 

   940 	

   941 	@leave KErrNotFound The specified entry was not a child of the context 

   942 	@leave KErrNotSupported If deleting entries from non-current drive

   943 	@return The operation object controlling the deletion command */

   944 	{

   945 #ifndef _NO_SESSION_LOGGING_

   946 	Log(_L("Asynchronous DeleteL, entry %x"), aId); 

   947 #endif

   948 

   949 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

   950 	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   951 	CleanupStack::PushL(selection);

   952 	selection->AppendL(aId);

   953 	CMsvOperation* operation = DoDeleteL(*selection, aStatus);

   954 	CleanupStack::PopAndDestroy(); // selection

   955 	return operation;

   956 	}

   957 

   958 

   959 

   960 EXPORT_C CMsvOperation* CMsvEntry::DeleteL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   961 //

   962 // Deletes a selection containing children of the context

   963 //

   964 /** Deletes child entries of the context asynchronously. 

   965 

   966 The delete works recursively through all the descendants. If a child or any 

   967 descendant is locked by another client or any store or file is open, then 

   968 that child will not be deleted. Any files and stores associated with the entries 

   969 are deleted.

   970 

   971 The returned CMsvOperation object completes when deletion is complete.

   972 

   973 @param aSelection List of ID of the entries to be deleted 

   974 @param aStatus The request status to be completed when the operation has finished 

   975 

   976 @leave KErrNotFound A specified entry was not a child of the context 

   977 @leave KErrNotSupported If deleting entries from non-current drive

   978 @return The operation object controlling the deletion command */

   979 	{

   980 #ifndef _NO_SESSION_LOGGING_

   981 	Log(_L("Asynchronous DeleteL with selection of %d entries"), aSelection.Count()); 

   982 #endif

   983 

   984 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

   985 	return DoDeleteL(aSelection, aStatus);

   986 	}

   987 

   988 

   989 

   990 CMsvOperation* CMsvEntry::DoDeleteL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   991 //

   992 //

   993 //

   994 	{

   995 	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

   996 	

   997 	if (!AreChildren(aSelection))

   998 		User::Leave(KErrNotFound);

   999 

  1000 	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);

  1001 	CleanupStack::PushL(operation);

  1002 	if (iEntryPtr->iType==KUidMsvRootEntry)

  1003 		{

  1004 		// we must be deleting services - so it is a local operation

  1005 		operation->iMtm = KUidMsvLocalServiceMtm;

  1006 		operation->iService = KMsvLocalServiceIndexEntryId;

  1007 		}

  1008 	else

  1009 		User::LeaveIfError(iMsvSession.Session().OperationMtmL(aSelection.At(0), operation->iMtm, operation->iService));

  1010 

  1011 #if defined(_DEBUG)

  1012 	// check other entries in selection are consistent and are not read only

  1013 	TInt dCount = aSelection.Count();

  1014 	while (dCount--)

  1015 		{

  1016 		if (iEntryPtr->iType!=KUidMsvRootEntry)

  1017 			{

  1018 				TMsvId service;

  1019 				TUid mtm;

  1020 				TInt error = iMsvSession.Session().OperationMtmL(aSelection.At(dCount), mtm, service);

  1021 				__ASSERT_DEBUG(error==KErrNone || error==KErrNotFound, PanicServer(EMsvNonConsistentDeleteSelection));

  1022 				__ASSERT_DEBUG(mtm==operation->iMtm, PanicServer(EMsvNonConsistentDeleteSelection));

  1023 				__ASSERT_DEBUG(service==operation->iService, PanicServer(EMsvNonConsistentDeleteSelection));

  1024 			}

  1025 		TMsvEntry dEntry;

  1026 		TMsvId dService;

  1027 		if (iMsvSession.Session().GetEntry(aSelection.At(dCount), dService, dEntry)==KErrNone)

  1028 			{

  1029 			__ASSERT_DEBUG(dService==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && dService==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && dService==aSelection.At(dCount)), PanicServer(EMsvDeletingEntryDifferentOwningService));

  1030 			}

  1031 		}

  1032 #endif

  1033 	

  1034 	iMsvSession.Session().DeleteEntriesL(aSelection, operation->Id(), operation->iStatus);

  1035 	operation->Start();

  1036 	CleanupStack::Pop(); // operation

  1037 	return operation;

  1038 	}

  1039 

  1040 EXPORT_C void CMsvEntry::DeleteL(TMsvId aId)

  1041 /** Deletes a child entry of the context synchronously. 

  1042 

  1043 The delete works recursively through all the descendants. If a child or any descendant is locked by another 

  1044 client or any store or file is open, then that child will not be deleted. Any files and stores associated 

  1045 with the entry are deleted.

  1046 

  1047 This function can only be used on local entries.

  1048 

  1049 @param aId ID of entry to be deleted

  1050 @leave KErrNotFound The specified entry was not a child of the context

  1051 @leave KErrNotSupported If deleting entries from non-current drive

  1052 */

  1053 	{

  1054 #ifndef _NO_SESSION_LOGGING_

  1055 	Log(_L("Synchronous DeleteL, entry %x"), aId); 

  1056 #endif

  1057 	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?

  1058 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

  1059 	

  1060 	User::LeaveIfError(CMsvEntry::DeleteOneL(aId));

  1061 	}

  1062 

  1063 EXPORT_C void CMsvEntry::DeleteL(const CMsvEntrySelection& aSelection, TMsvLocalOperationProgress& aProgress)

  1064 /** Deletes child entries of the context synchronously. 

  1065 

  1066 The delete works recursively through all the descendants. If a child or any 

  1067 descendant is locked by another client or any store or file is open, then 

  1068 that child will not be deleted. Any files and stores associated with the entries 

  1069 are deleted.

  1070 

  1071 @param aSelection List of ID of the entries to be deleted 

  1072 @param aProgress Progress information for the delete operation

  1073 @leave KErrNotFound A specified entry was not a child of the context 

  1074 @leave KErrNotSupported If deleting entries from non-current drive */

  1075 	{

  1076 #ifndef _NO_SESSION_LOGGING_

  1077 	Log(_L("Synchronous DeleteL with selection of %d entries"), aSelection.Count()); 

  1078 #endif

  1079 

  1080 	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?

  1081 	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

  1082 	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

  1083 

  1084 	if (!AreChildren(aSelection))

  1085 		User::Leave(KErrNotFound);

  1086 

  1087 	aProgress.iTotalNumberOfEntries=aSelection.Count();

  1088 	aProgress.iNumberCompleted=0;

  1089 	aProgress.iNumberRemaining=aProgress.iTotalNumberOfEntries;

  1090 	aProgress.iError=KErrNone;

  1091 

  1092 	TInt count=aProgress.iTotalNumberOfEntries;

  1093 	while(count--)

  1094 		{

  1095 		aProgress.iId=aSelection.At(count);

  1096 		TInt err=DeleteOneL(aProgress.iId);

  1097 		aProgress.iNumberRemaining--;

  1098 		if(err==KErrNone)

  1099 			aProgress.iNumberCompleted++;

  1100 		else

  1101 			{

  1102 			aProgress.iError=err;

  1103 			aProgress.iNumberFailed++;

  1104 			}

  1105 		}

  1106 	}

  1107 

  1108 

  1109 TInt CMsvEntry::DeleteOneL(TMsvId aMsvId)

  1110 	{

  1111 	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;

  1112 	CleanupStack::PushL(selection);

  1113 	selection->AppendL(aMsvId);

  1114 	TInt opid = iMsvSession.OperationId();

  1115 	iMsvSession.Session().DeleteEntriesL(*selection, opid);

  1116 

  1117 	TMsvLocalOperationProgress progress;

  1118 	TPckg<TMsvLocalOperationProgress> progressPack(progress);

  1119     User::LeaveIfError(iMsvSession.Session().OperationCompletion(opid, progressPack));

  1120 	

  1121 	if(progress.iError==KErrNone)

  1122 		{

  1123 		TMsvId id = selection->At(0);

  1124 		TInt ii = iSortedChildren->Count();

  1125 		while (ii--)

  1126 			{

  1127 			if (iSortedChildren->At(ii)->Id() == id)

  1128 				{

  1129 				iSortedChildren->Delete(ii);

  1130 				break;

  1131 				}

  1132 			}

  1133 

  1134 		ii = iEntries->Count();