// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).+
−
// All rights reserved.+
−
// This component and the accompanying materials are made available+
−
// under the terms of "Eclipse Public License v1.0"+
−
// which accompanies this distribution, and is available+
−
// at the URL "http://www.eclipse.org/legal/epl-v10.html".+
−
//+
−
// Initial Contributors:+
−
// Nokia Corporation - initial contribution.+
−
//+
−
// Contributors:+
−
//+
−
// Description:+
−
//+
−
+
−
#ifdef _DEBUG+
−
#undef _NO_SERVER_LOGGING_+
−
#endif+
−
+
−
/**+
−
 * User Includes+
−
 */+
−
#include "MSVSERV.H"+
−
#include "MSVARRAY.H"+
−
#include "msvdbadapter.h"+
−
#include "msvcacheentry.h"+
−
#include "msvindexadapter.h"+
−
#include "msventryfreepool.h"+
−
#include "msvcachevisiblefolder.h"+
−
#include "msvsearchsortdeltacache.h"+
−
#include "msvsearchsortcachemanager.h"+
−
+
−
/**+
−
 *System Includes+
−
 */+
−
#include <msvuids.h>+
−
#include <msvstd.h>+
−
+
−
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +
−
#include "msvconsts.h"+
−
#endif+
−
+
−
/**+
−
 * MACRO DEFINITIONS+
−
 */+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	#define INITIAL_NUM_ENTRIES 10+
−
#else+
−
	#define INITIAL_NUM_ENTRIES 13+
−
#endif+
−
+
−
/**+
−
 * CONSTANT DEFINITIONS+
−
 */+
−
const TInt KMsvMtmListGranularity=8;+
−
const TInt KMsvChangeAttributesListGranularity=32;+
−
+
−
+
−
+
−
/**+
−
 * FUNCTION DEFINITIONS+
−
 */+
−
+
−
+
−
+
−
/**+
−
 * CMsvIndexAdapter()+
−
 */+
−
CMsvIndexAdapter::CMsvIndexAdapter(CMsvServer& aServer)+
−
    :CActive(EPriorityStandard), iServer(aServer), iFolderListHeader(CMsvCacheVisibleFolder::iOffset)+
−
	{	+
−
	CActiveScheduler::Add(this);		+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * ~CMsvIndexAdapter()+
−
 */+
−
CMsvIndexAdapter::~CMsvIndexAdapter()+
−
	{+
−
+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Destroying CMsvIndexAdapter object."));+
−
#endif+
−
	+
−
	Cancel();+
−
	+
−
	// 1. Close the database.+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Closing the database."));+
−
#endif+
−
	if(iDbAdapter != NULL)+
−
		delete iDbAdapter;+
−
+
−
	// 2. Delete Cache.+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Destroying Cache."));+
−
#endif+
−
	+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
+
−
    dqIter.SetToFirst();+
−
    while ((folderNode = dqIter++) != NULL)+
−
        {+
−
        folderNode->iDlink.Deque();+
−
        delete folderNode;+
−
        }+
−
    +
−
    iFreePoolInstance->ReleaseEntry(iRootEntry);+
−
    iRootEntry = NULL;+
−
+
−
    // 3. Delete internal data structure.+
−
    iNonCommittedAddedEntryList.ResetAndDestroy();+
−
    iNonCommittedChangedEntryList.Reset();+
−
    iNonCommittedAddedEntryList.Close();+
−
	iNonCommittedChangedEntryList.Close();+
−
    +
−
    // 4. Flush extra memory in entry freepool.+
−
    if(iFreePoolInstance != NULL)+
−
    	{+
−
    	iFreePoolInstance->FlushExcessMemory();	+
−
    	}+
−
	+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	// Added for 557.+
−
	iMaxMsvIdList.Close();+
−
#endif+
−
+
−
	delete iIdle;+
−
	}+
−
+
−
+
−
+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
/**+
−
 * NewL()+
−
 * @return The newly created index adapter object.+
−
 * +
−
 * Function added as part of PREQ 557.+
−
 * It returns an instance of CMsvIndexAdapter class. +
−
 */+
−
CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer)+
−
	{+
−
	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);+
−
	CleanupStack::PushL(self);+
−
	+
−
	self->ConstructL();+
−
	+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * ConstructL()+
−
 * +
−
 * Function added as part of PREQ 557.+
−
 * The function is called from NewL().+
−
 * 1. Create the DB adapter object.+
−
 * 2. Initialize freepool object.+
−
 * 3. Create the root entry in cache.+
−
 * 4. Browse through the preferred drive list.+
−
 *    i. For each drive in the preferred drive list the function +
−
 *       assigns a unique drive-id (0< Id <8).+
−
 *	 ii. Attach the DB to the primary database.+
−
 *  iii. Update the maxId of the database to MaxId table.+
−
 *   iv. If the database is not compatible or corrupt, update the +
−
 *       appropriate drive status in CMsvServer data structure.+
−
 *    v. Fetch children of root entry and Local-Service entry from the DB to the cache.      +
−
 */+
−
void CMsvIndexAdapter::ConstructL()+
−
	{+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Inside ConstructL()..."));+
−
#endif+
−
	+
−
	// Create database adapter object.+
−
	iDbAdapter = CMsvDBAdapter::NewL();+
−
		+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("The database object is created succesfully."));+
−
#endif+
−
	+
−
	iProgress.iCompleted = 0;+
−
	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;+
−
	+
−
	// Initialize freepool object.+
−
	iFreePoolInstance = CMsvEntryFreePool::Instance();+
−
	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);+
−
	+
−
	// Drive id zero will be synonym of KCurrentDriveId. Drive+
−
	// id of a drive (including current) drive will never be zero.+
−
	// Drive of the current drive will always by KCurrentDriveId.+
−
	TUint driveId = KCurrentDriveId;+
−
+
−
	// Since driveId starts from 1, the first +
−
	// entry in iMaxMsvIdList is not used.+
−
	// Enter a dummy entry in location zero.+
−
	iMaxMsvIdList.InsertL(0, 0);+
−
	+
−
	iProgress.iCompleted++;+
−
	iProgress.iRemaining--;+
−
	iProgress.iId = KMsvRootIndexEntryId;+
−
	+
−
	// For each drive in the preferred drive list, perform followings...+
−
	// 1. Check if a valid message store is available.+
−
	// 2. If not, skip the drive.+
−
	// 3. Assign a new drive Id to the drive and+
−
	//    update the entry in preferred drive list.+
−
	// 4. Attach the drive database to the primary DB.+
−
	// 5. Update the max Id list.+
−
	// 6. For current drive, fetch the children of root entry into cache.+
−
	// 7. Fetch children of localService into cache.+
−
	CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();+
−
	TUint curDriveIndex = driveList->CurrentDriveIndex();+
−
	for(TInt index=curDriveIndex; index<driveList->Count(); index++)+
−
		{+
−
		TMsvPreferredDrive driveEntry;+
−
		driveList->DriveInfoL(index, driveEntry);+
−
		+
−
		if(EMsvMessageStoreAvailableStatus == driveEntry.status)+
−
			{+
−
			// Assign a unique drive-id.+
−
			driveList->UpdateDriveIdL(index, driveId);+
−
			+
−
			// Attach the database.+
−
			TMsvId maxId;+
−
			iDbAdapter->AttachDBL(driveEntry.driveNum, driveId, maxId);+
−
			+
−
			// Insert the max Id in the list.+
−
			iMaxMsvIdList.InsertL( ((maxId >= MaskTMsvId(driveId, KFirstFreeEntryId))? (maxId+1): MaskTMsvId(driveId, KFirstFreeEntryId)), driveId);+
−
			driveId++;+
−
			}+
−
		iProgress.iCompleted++;+
−
		iProgress.iRemaining--;+
−
		}+
−
+
−
	iFirstFreeDriveId = (driveId%8)? (driveId%8): 2;+
−
+
−
	// Initializing remaining entries in MaxMsvId list.+
−
	for(TInt index=driveId; index<8; index++)+
−
		{+
−
		iMaxMsvIdList.InsertL(NULL, index);+
−
		}+
−
	+
−
	// For current drive fetch children of root entries also.+
−
	RPointerArray<CMsvCacheEntry> childEntryList;+
−
	CleanupClosePushL(childEntryList);	+
−
	// Create root entry node in the cache. A root folder node will never +
−
	// be swapped out of cache. The children of root entry will be the +
−
	// children of root entry in the current drive.+
−
	// Root id is masked to set the driveId in the folder node.+
−
	iRootNode = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvRootIndexEntryId));+
−
	iFolderListHeader.AddFirst(*iRootNode);+
−
	iRootNode->SetComplete(ETrue);+
−
	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childEntryList);+
−
	iRootNode->AddEntryListL(childEntryList, ETrue);+
−
	childEntryList.Reset();+
−
	+
−
	// Fetch child of LocalServices.+
−
	CMsvCacheVisibleFolder* localServiceFolder = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvLocalServiceIndexEntryId));+
−
	iFolderListHeader.AddFirst(*localServiceFolder);+
−
	iDbAdapter->GetChildrenL(KMsvLocalServiceIndexEntryId, childEntryList);+
−
	localServiceFolder->AddEntryListL(childEntryList, ETrue);+
−
	CleanupStack::PopAndDestroy(1);   //childEntryList+
−
		+
−
	// Create root entry.+
−
	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.+
−
	iRootEntry->Entry().iType = KUidMsvRootEntry;+
−
	iRootEntry->Entry().iDate.UniversalTime();+
−
	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);+
−
	iRootEntry->Entry().SetParent(KErrNotFound);+
−
	iRootEntry->Entry().SetOwner(ETrue);+
−
	iRootEntry->Entry().iSize = 0;+
−
	+
−
	// Update progress+
−
	iProgress.iCompleted = iProgress.iTotal;+
−
	iProgress.iRemaining = 0;+
−
	iProgress.iId = KMsvRootIndexEntryId;+
−
+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Cache initialized succesfully."));+
−
#endif+
−
	+
−
	iIdle = CIdle::NewL(CActive::EPriorityIdle);+
−
	CompleteSelf();+
−
	}+
−
+
−
+
−
+
−
/**+
−
GetInPreparationIds+
−
*/+
−
void CMsvIndexAdapter::GetInPreparationIds(CMsvEntrySelection& aSelection, TUint aDriveId /*DEFAULT = 0 */)+
−
	{+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->GetInPreparationIdL(aSelection, aDriveId));+
−
		}+
−
	}+
−
+
−
+
−
#else		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
+
−
/**+
−
 * NewL()+
−
 * @param TFileName: DB File Name.+
−
 * @return The newly created index adapter.+
−
 * +
−
 * It returns an instance of CMsvIndexAdapter class. +
−
 */+
−
CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer, const TFileName& aDbFileName)+
−
	{+
−
	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);+
−
	CleanupStack::PushL(self);+
−
	+
−
	self->ConstructNewL(aDbFileName);+
−
	+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * OpenL()+
−
 * @param TFileName: DB File Name.+
−
 * @return The newly created index adapter.+
−
 * +
−
 * It returns an instance of CMsvIndexAdapter class. +
−
 */+
−
CMsvIndexAdapter* CMsvIndexAdapter::OpenL(CMsvServer& aServer, const TFileName& aDbFileName)+
−
	{+
−
	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);+
−
	CleanupStack::PushL(self);+
−
	+
−
	self->ConstructOpenL(aDbFileName);+
−
	+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * ConstructNewL()+
−
 * +
−
 * The function is called from NewL().+
−
 * 1. Check if a database with the passed name already exists.+
−
 * 1.1. If yes, open the database.+
−
 * 1.2. If no, create a new database with the same name.+
−
 * 2. Creates entry cache.+
−
 * 3. If a new database is created, create root entry also.+
−
 */+
−
void CMsvIndexAdapter::ConstructNewL(const TFileName& aDbFileName)+
−
	{+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));+
−
#endif+
−
	+
−
	// Delete the database first, if it already exists.+
−
	CMsvDBAdapter::DeleteDB(aDbFileName);+
−
	+
−
	// Get the instance of free pool.+
−
	iFreePoolInstance = CMsvEntryFreePool::Instance();+
−
+
−
	// Create the new database with the same name.+
−
	// If this leaves, nothing can be done and let NewL() leave.+
−
	iDbAdapter = CMsvDBAdapter::NewL(aDbFileName);+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("A new database %s is created..."), &aDbFileName);+
−
#endif+
−
	+
−
	iProgress.iTotal = iProgress.iRemaining = 1; //root+
−
	// Create root entry. +
−
	CreateInitialSetOfEntriesL();+
−
	+
−
+
−
#ifndef _NO_SERVER_LOGGING_+
−
//	iServer.Log(_L("Cache initialized succesfully."));+
−
#endif+
−
	+
−
	iNextCreateId = KFirstFreeEntryId;+
−
	iIdle = CIdle::NewL(CActive::EPriorityIdle);+
−
	CompleteSelf();+
−
	}+
−
		+
−
+
−
+
−
+
−
	+
−
/**+
−
 * ConstructOpenL()+
−
 * +
−
 * The function is called from NewL().+
−
 * 1. Check if a database with the passed name already exists.+
−
 * 1.1. If yes, open the database.+
−
 * 1.2. If no, create a new database with the same name.+
−
 * 2. Creates entry cache.+
−
 * 3. If a new database is created, it then read message resource file +
−
 *    and creates entry as mentioned in cache and database.+
−
 */+
−
void CMsvIndexAdapter::ConstructOpenL(const TFileName& aDbFileName)+
−
	{+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));+
−
#endif+
−
	+
−
	// Get the instance of free pool+
−
	iFreePoolInstance = CMsvEntryFreePool::Instance();+
−
+
−
	// Open the database.+
−
	iDbAdapter = CMsvDBAdapter::OpenL(aDbFileName);+
−
	+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Opening database %s is succesful."), &aDbFileName);+
−
#endif+
−
		+
−
	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;	+
−
	CreateInitialCacheL();+
−
+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Cache initialized succesfully."));+
−
#endif+
−
+
−
	TMsvId tmpNextId = NULL;+
−
	iDbAdapter->GetMaxTMsvIdL(tmpNextId);+
−
	iNextCreateId = (tmpNextId >= KFirstFreeEntryId)? (tmpNextId+1) : KFirstFreeEntryId;+
−
	+
−
	iIdle = CIdle::NewL(CActive::EPriorityIdle);+
−
	CompleteSelf();+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * CreateInitialSetOfEntries()+
−
 * +
−
 * The function is called from ConstructL(), whenever a new DB is created.+
−
 * The function creates root entry into database and cache.+
−
 */+
−
void CMsvIndexAdapter::CreateInitialSetOfEntriesL()+
−
	{+
−
	+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Inside CreateInitialSetOfEntriesL(): Creating standard entries for new DB."));+
−
#endif+
−
	+
−
	// 1. Initialize the instance of free pool.+
−
	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);+
−
		+
−
	// 2. Creating root entry into database.+
−
	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.+
−
	iRootEntry->Entry().iType = KUidMsvRootEntry;+
−
	iRootEntry->Entry().iDate.UniversalTime();+
−
	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);+
−
	iRootEntry->Entry().SetParent(KErrNotFound);+
−
	iRootEntry->Entry().iSize = 0;+
−
	+
−
	TMsvId visibleFolderId = KMsvRootIndexEntryId;+
−
	iDbAdapter->CreateEntryL(iRootEntry->Entry(), visibleFolderId);+
−
	+
−
	// 3. Add root entry to cache as well+
−
	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);+
−
	iFolderListHeader.AddFirst(*rootFolder);+
−
	rootFolder->SetComplete(ETrue);+
−
	+
−
	// Update progress+
−
	iProgress.iCompleted++;+
−
	iProgress.iRemaining--;+
−
	iProgress.iId = KMsvRootIndexEntryId;+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * CreateInitialCache()+
−
 * +
−
 * The function is called from NewL(), whenever an existing DB is opened.+
−
 * It creates the intial cache. It creates root entry in cache and fetches+
−
 * child of root from DB and push them into cache. It then fetches child+
−
 * entries of LocalServices and push them too into cache. +
−
 * +
−
 * >>>> The function can be enhanced to load children of additional folders+
−
 * to cache along with the above standard folders. These additional folders +
−
 * can be mentioned by licensees in msgs.ini file.+
−
 */+
−
void CMsvIndexAdapter::CreateInitialCacheL()+
−
	{+
−
#ifndef _NO_SERVER_LOGGING_+
−
	iServer.Log(_L("Inside CreateInitialCache(): Initializing Cache."));+
−
#endif+
−
+
−
	//1. Initialize the instance of free pool.+
−
	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);+
−
	+
−
	// 2. Add root entry to cache.+
−
	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);+
−
	iFolderListHeader.AddFirst(*rootFolder);+
−
	// 2.1 Update progress+
−
	iProgress.iCompleted++;+
−
	iProgress.iRemaining--;+
−
	iProgress.iId = KMsvRootIndexEntryId;+
−
	+
−
	// 3. Fetch child of root entries from DB.+
−
	RPointerArray<CMsvCacheEntry> childrenOfRoot;+
−
	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childrenOfRoot);+
−
+
−
	// 3.1 Get the root entry from DB.+
−
	CMsvCacheEntry *rootEntry = NULL;+
−
	TMsvId visibleFolder = NULL;+
−
	iDbAdapter->GetEntryL(KMsvRootIndexEntryId, rootEntry, visibleFolder);+
−
	// 3.2 Copy the TMsvEntry of root from CMsvCacheEntry.+
−
	//Mem::Copy(&iRootEntry->Entry(), &rootEntry->Entry(), sizeof(TMsvEntry));+
−
	iRootEntry = rootEntry;+
−
	// 3.3 Release the cache entry back to the freepool.+
−
	//iFreePoolInstance->ReleaseEntry(rootEntry);	+
−
	+
−
	// 4. Add children to cache.+
−
	rootFolder->AddEntryListL(childrenOfRoot, ETrue);+
−
	// 4.1 Update progress+
−
	iProgress.iCompleted += 4;+
−
	iProgress.iRemaining -= 4;+
−
	iProgress.iId = KMsvLocalServiceIndexEntryId;+
−
	+
−
	// 5. Set the visible folder as complete+
−
	rootFolder->SetComplete(ETrue);+
−
	+
−
	+
−
	// 6. Fetch child of LocalServices+
−
	childrenOfRoot.Reset();+
−
	iDbAdapter->GetChildrenL(KMsvLocalServiceIndexEntryId, childrenOfRoot);+
−
	+
−
	CMsvCacheVisibleFolder* localFolder = CMsvCacheVisibleFolder::NewL(KMsvLocalServiceIndexEntryId);+
−
	iFolderListHeader.AddFirst(*localFolder);+
−
		+
−
	// 7. Add children to cache.+
−
	localFolder->AddEntryListL(childrenOfRoot);+
−
	// 7.1 Update progress+
−
	iProgress.iCompleted = iProgress.iTotal;+
−
	iProgress.iRemaining = 0;+
−
	iProgress.iId = KMsvGlobalInBoxIndexEntryId;+
−
	+
−
	// 8. Set the visible folder as complete+
−
	localFolder->SetComplete(ETrue);+
−
	childrenOfRoot.Close();+
−
	}+
−
	+
−
+
−
+
−
/**+
−
GetInPreparationIds+
−
*/+
−
void CMsvIndexAdapter::GetInPreparationIds(CMsvEntrySelection& aSelection)+
−
	{+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->GetInPreparationIdL(aSelection));+
−
		}	+
−
	}+
−
+
−
+
−
#endif 		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
+
−
/**+
−
 *CompleteSelf+
−
 *This will make sure that Runl is called.+
−
 */+
−
void CMsvIndexAdapter::CompleteSelf()+
−
	{+
−
	iStatus=KRequestPending;+
−
	SetActive();+
−
	TRequestStatus* st=&iStatus;+
−
	User::RequestComplete(st, KErrNone);+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * RunL()+
−
 */+
−
void CMsvIndexAdapter::RunL()+
−
	{+
−
	// Set the state for the background state machine.+
−
	iBackgroundOperationState = ERemoveDeletedEntries;+
−
	iBackgroundOperationPerformed = 0;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * DoCancel()+
−
 */+
−
void CMsvIndexAdapter::DoCancel()+
−
	{+
−
	iIdle->Cancel();	+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * AddEntry()+
−
 */+
−
TInt CMsvIndexAdapter::AddEntry(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId)+
−
	{+
−
	TRAPD(err, DoAddEntryL(aEntry, aOwnerId, aAutoAssignId));+
−
	return err;+
−
	}+
−
+
−
+
−
/**+
−
 * AddEntryNoCommit()+
−
 */+
−
TInt CMsvIndexAdapter::AddEntryNoCommit(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId)+
−
	{+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->BeginTransactionL());+
−
		}+
−
	else+
−
		{+
−
		return ErrorState();+
−
		}+
−
	TRAPD(err, DoAddEntryL(aEntry, aOwnerId, aAutoAssignId, EFalse));+
−
	if(err)+
−
		{+
−
		RollbackAdditions();+
−
		}+
−
	return err;+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * DoAddEntryL()+
−
 * +
−
 * Add the entry to the index and then the file. +
−
 * If either fails the function leaves. Creates +
−
 * its own copy of TMsvEntry (SetEntryL() code). +
−
 * This can be optimized further.+
−
 */+
−
void CMsvIndexAdapter::DoAddEntryL(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId, TBool aCommitToDb)+
−
	{+
−
	// Leave if the message store is not currently available.+
−
    User::LeaveIfError(iErrorState);+
−
    +
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	// get and set the unique id+
−
	if (aAutoAssignId)+
−
		{+
−
		aEntry.SetId(NextId(GetDriveId(aEntry.Parent())));+
−
		}+
−
+
−
	if (aEntry.iType == KUidMsvServiceEntry)+
−
		{+
−
		if(KMsvLocalServiceIndexEntryId == UnmaskTMsvId(aEntry.iId))+
−
			{+
−
			aEntry.iServiceId = KMsvLocalServiceIndexEntryId;+
−
			}+
−
		else+
−
			{+
−
			aEntry.iServiceId = aEntry.Id();+
−
			}+
−
		}+
−
#else		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	if (aAutoAssignId)+
−
		{+
−
		aEntry.SetId(NextId());+
−
		}+
−
+
−
	if (aEntry.iType == KUidMsvServiceEntry)+
−
		{+
−
		aEntry.iServiceId = aEntry.Id();+
−
		}+
−
#endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
	CMsvCacheEntry* parentEntry = NULL;+
−
	FindEntryL(aEntry.Parent(), parentEntry);+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	if(UnmaskTMsvId(aEntry.iId) == KMsvDeletedEntryFolderEntryId)+
−
		{+
−
		aEntry.SetVisibleFolderFlag(ETrue);+
−
		}+
−
	else	+
−
#endif+
−
		{		+
−
		// If entry is set to visible while creation, then set the visible folder+
−
		// flag to ETrue, this will not change for the lifetime of an TMsvEntry.+
−
		if(parentEntry->Entry().VisibleFolderFlag())+
−
			{+
−
			if( (aEntry.Visible()) && +
−
			    (aEntry.iType == KUidMsvFolderEntry || aEntry.iType == KUidMsvServiceEntry)+
−
			  )+
−
				{+
−
				aEntry.SetVisibleFolderFlag(ETrue);+
−
				}+
−
			else+
−
				{+
−
				aEntry.SetVisibleFolderFlag(EFalse);+
−
				}				+
−
			}+
−
		else+
−
			{+
−
			aEntry.SetVisibleFolderFlag(EFalse);+
−
			}+
−
		}+
−
		+
−
	aEntry.SetOwner(EFalse);+
−
	TMsvId visibleFolderId;+
−
	if(!GetVisibleFolderId(aEntry.Parent(), visibleFolderId))+
−
		{+
−
		User::Leave(KErrNotFound);+
−
		}+
−
    +
−
	// Add entry to cache.      +
−
    CMsvCacheEntry* newCacheEntry = NULL;   +
−
    newCacheEntry = iFreePoolInstance->EntryL();+
−
    // Set the owner ID of the entry - the SID of the owning process.+
−
    newCacheEntry->SetEntryOwnerId(aOwnerId);+
−
    +
−
    CMsvCacheVisibleFolder* visibleFolder = NULL;+
−
    TRAPD(err, newCacheEntry->SetEntryL(aEntry);+
−
               visibleFolder = AddEntryToCacheL(visibleFolderId, newCacheEntry);+
−
         );+
−
    if(err)+
−
        {+
−
        iFreePoolInstance->ReleaseEntryWithoutTransaction(newCacheEntry);+
−
        User::Leave(err);+
−
        }+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
    TRAP(err,+
−
            if(aCommitToDb)+
−
                iDbAdapter->BeginTransactionL();+
−
            iDbAdapter->CreateEntryL(aEntry, visibleFolderId);+
−
            // Set the owner flag of parent entry if not already done.+
−
            // For standard entry created from indexContext, parent Id will not be masked.+
−
            iDbAdapter->UpdateOwnerStatusL(MaskTMsvId(GetDriveId(aEntry.iId), aEntry.Parent()), parentEntry->Entry(), ETrue);+
−
            if(aCommitToDb)+
−
                iDbAdapter->CommitTransactionL();+
−
        );+
−
#else+
−
    TRAP(err,+
−
            if(aCommitToDb)+
−
                iDbAdapter->BeginTransactionL();+
−
            iDbAdapter->CreateEntryL(aEntry, visibleFolderId);+
−
            // Set the owner flag of parent entry if not already done.+
−
            // For standard entry created from indexContext, parent Id will not be masked.+
−
            iDbAdapter->UpdateOwnerStatusL(aEntry.Parent(), parentEntry->Entry(), ETrue);+
−
            if(aCommitToDb)+
−
                iDbAdapter->CommitTransactionL();+
−
        );+
−
#endif  +
−
    if(err & KSqlErrConstraint != err)+
−
        {+
−
        if(aCommitToDb)+
−
            iDbAdapter->RollbackTransactionL();+
−
        // This will not leave...+
−
        TRAP_IGNORE(visibleFolder->DeleteEntryL(newCacheEntry->GetId()));+
−
        User::Leave(err);+
−
        }	+
−
	parentEntry->Entry().SetOwner(ETrue);+
−
+
−
	if(!aCommitToDb)+
−
		{+
−
		// Add entry to the list of non-committed entries.+
−
		CNonCommittedAddedEntries* nonCommittedAddedEntries = new(ELeave)CNonCommittedAddedEntries(visibleFolderId, newCacheEntry);+
−
		CleanupStack::PushL(nonCommittedAddedEntries);+
−
		iNonCommittedAddedEntryList.AppendL(nonCommittedAddedEntries);+
−
		CleanupStack::Pop(nonCommittedAddedEntries);+
−
		}+
−
+
−
	if(aEntry.iType.iUid == KUidMsvMessageEntryValue && CMSvSearchSortCacheManager::Instance()->iManagerEntry != NULL)+
−
		{	+
−
		TMsgType aType(ENewMsg);+
−
		if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0)+
−
			{+
−
			CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aEntry.Id(),aType);+
−
			}+
−
		}	+
−
	}+
−
	+
−
	+
−
+
−
+
−
/**+
−
 * GetVisibleFolderId()+
−
 * +
−
 * Returns ETrue, if the parent entry exists. Otherwise returns EFalse.+
−
 * IN: Parent Id of the entry, whose immediate visible folder has to be found.+
−
 * OUT: Visible folder Id.+
−
 */+
−
TBool CMsvIndexAdapter::GetVisibleFolderId(TMsvId aParentId, TMsvId& aVisibleFolderId)+
−
	{+
−
	// If the entry is either a root entry (parent=KErrNotFound) or +
−
	// child of root entry its visibleFolderId will be root entry itself.+
−
	if((KErrNotFound == aParentId) || (KMsvRootIndexEntryId == aParentId))+
−
		{+
−
		aVisibleFolderId = KMsvRootIndexEntryId;+
−
		return ETrue;+
−
		}+
−
	+
−
	// Get the visible flag of parent entry.+
−
	+
−
	// If parent entry is visible, then immediateVisibleFolder of child+
−
	// should be parent Id. And if it is invisible then child's immediateVisibleFolder +
−
	// should be same as parent's immediateVisibleFolder.+
−
	// First check in cache.+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		CMsvCacheVisibleFolder* folderNode = NULL;+
−
		TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
		dqIter.SetToFirst(); +
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			// Check if the current folder node is parent.+
−
			if( aParentId == folderNode->GetFolderId() )+
−
				{+
−
				aVisibleFolderId = aParentId;+
−
				return ETrue;+
−
				}+
−
			}+
−
		dqIter.SetToFirst(); +
−
		CMsvCacheEntry* entry;+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			// Check if the current folder node is parent.+
−
			if(folderNode->GetEntry(aParentId, entry))+
−
				{+
−
				if(entry->Entry().VisibleFolderFlag())+
−
					{+
−
					aVisibleFolderId = aParentId;+
−
					}+
−
				else+
−
					{+
−
					//If the visible folder is not the parent, then+
−
					//the current folder must be the visible folder,+
−
					//as otherwise the parent would have been under another+
−
					//folder node.+
−
					aVisibleFolderId = folderNode->GetFolderId();+
−
					}+
−
				return ETrue;+
−
				}+
−
			}+
−
		}+
−
	+
−
	// Entry cannot be found in cache,+
−
	// Now search in DB.+
−
	TInt err = KErrNone;+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP(err, iDbAdapter->GetVisibleFolderIdL(aParentId, aVisibleFolderId));+
−
		}+
−
	else+
−
		{+
−
		return EFalse;+
−
		}+
−
	if(KErrNone == err)+
−
		{+
−
		return ETrue; 		+
−
		}+
−
	return EFalse;		+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * DeleteEntry()+
−
 */+
−
TInt CMsvIndexAdapter::DeleteEntry(TMsvId aId)+
−
	{+
−
	CMsvEntrySelection* selection = NULL;+
−
	+
−
	TRAPD(error, selection = new(ELeave)CMsvEntrySelection; selection->AppendL(aId););+
−
	if(KErrNone == error)+
−
		{+
−
		error = DeleteSelection(*selection);+
−
		}+
−
+
−
	TMsgType aType(EDeletedMsg);+
−
	if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0 && error == KErrNone)+
−
		{+
−
		CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aId,aType);+
−
		}+
−
+
−
	delete selection;+
−
	return error;+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * DeleteSelection+
−
 * Deletes a selection of entries.+
−
 *+
−
 * @param aSelection Selection of TMsvIds of the entries to be deleted+
−
 * @return TInt System-wide error code.+
−
 */+
−
TInt CMsvIndexAdapter::DeleteSelection(const CMsvEntrySelection& aSelection)+
−
	{+
−
	TInt count = aSelection.Count();+
−
+
−
	if(!iDbAdapter)+
−
		{+
−
		return ErrorState();+
−
		}+
−
	// Only start a transaction if there are more than 1 entries to be deleted.+
−
	if(count > 1)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->BeginTransactionL());		+
−
		}+
−
	// If the transaction is opened, deleted+
−
	// entry will be released temporarily.+
−
	iFreePoolInstance->BeginTransaction();+
−
	TInt error = KErrNone;+
−
	TRAP(error, DoDeleteSelectionL(aSelection));+
−
	if (error)+
−
		{+
−
		if(count > 1)+
−
			{+
−
			TRAP_IGNORE(iDbAdapter->RollbackTransactionL());+
−
			}+
−
		iFreePoolInstance->RollbackTransaction();+
−
		}+
−
	else+
−
		{+
−
		if(count > 1)+
−
			{+
−
			TRAP_IGNORE(iDbAdapter->CommitTransactionL());+
−
			}	+
−
		iFreePoolInstance->CommitTransaction();+
−
		}+
−
	return error;+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * DoDeleteSelectionL+
−
 */+
−
void CMsvIndexAdapter::DoDeleteSelectionL(const CMsvEntrySelection& aSelection)+
−
	{+
−
	User::LeaveIfError(iErrorState);+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	const TInt count = aSelection.Count();+
−
	if(count <= 0)+
−
		{+
−
		return;+
−
		}+
−
	+
−
	CMsvCacheEntry* entry = NULL;+
−
	TBool releaseEntry = FindEntryL(aSelection.At(0), entry, EFalse);+
−
	TMsvId parentId = entry->Entry().Parent();+
−
	if(releaseEntry)+
−
		{+
−
		iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
		}+
−
	CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;+
−
	CleanupStack::PushL(children);+
−
	+
−
	for (TInt index=0; index<count; ++index)+
−
		{+
−
		dqIter.SetToFirst(); +
−
		TBool found = EFalse;+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			TRAPD(err, folderNode->DeleteEntryL(aSelection.At(index)));	+
−
			if(err != KErrNotFound && err != KErrNone)+
−
				{+
−
				User::Leave(err);+
−
				}+
−
			 else if(err == KErrNone)	+
−
			 	{+
−
			 	found = ETrue;+
−
			 	break;+
−
			 	}+
−
			}+
−
		if(!found)+
−
			{+
−
			if(iDbAdapter)+
−
				{+
−
				if(iDbAdapter->EntryExistsL(aSelection.At(index)))+
−
					{+
−
					User::Leave(KErrAccessDenied);+
−
					}+
−
				}+
−
			else+
−
				{+
−
				User::Leave(ErrorState());	+
−
				}+
−
			User::Leave(KErrNotFound);+
−
			}+
−
		+
−
		if(iDbAdapter)+
−
			{+
−
			iDbAdapter->DeleteEntryL(aSelection.At(index));+
−
			}+
−
		else+
−
			{+
−
			User::Leave(ErrorState());	+
−
			}+
−
		}+
−
	//Find the parent entry in cache and check for any children.+
−
	//If there are no more children under the parent, then+
−
	//reset the owner flag in cache and database.+
−
	TRAPD(err, releaseEntry = FindEntryL(parentId, entry, EFalse));+
−
	//If parent was also deleted then nothing left to do.+
−
	if(err == KErrNotFound)+
−
		{+
−
		CleanupStack::PopAndDestroy(); //children+
−
		return;+
−
		}+
−
	TRAP(err, +
−
		GetChildrenIdL(parentId, *children);+
−
		if(0 == children->Count() && entry->Entry().Owner())+
−
			{+
−
			if(iDbAdapter)+
−
				{+
−
				iDbAdapter->UpdateOwnerStatusL(parentId, entry->Entry(), EFalse);		+
−
				}+
−
			else+
−
				{+
−
				User::Leave(ErrorState());+
−
				}+
−
			entry->Entry().SetOwner(EFalse);+
−
			}+
−
		);+
−
	// Release the entry, since it is not added to cache.+
−
	if(releaseEntry)+
−
		{+
−
		iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
		}+
−
	User::LeaveIfError(err);+
−
	CleanupStack::PopAndDestroy(); //children+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * ExpandSelectionRecursively()+
−
 * Expands a selection to include all the descendents of the entries. They are order+
−
 * in such a way that they can be deleted in order, children first+
−
 *+
−
 * @param aSelection CMsvEntrySelection, which contains the TMsvIds of the entry passed.+
−
 * @return TInt System wide error code.+
−
 */+
−
TInt CMsvIndexAdapter::ExpandSelectionRecursively(CMsvEntrySelection& aSelection)+
−
	{+
−
	TInt error = KErrNone;+
−
	iOrigEntryPos=0;+
−
	iRecursionSelection=&aSelection;+
−
	TInt count = aSelection.Count();+
−
	while (iOrigEntryPos < count)+
−
		{+
−
		TMsvId entryId = aSelection.At(iOrigEntryPos);+
−
		if( !EntryExists(entryId) )+
−
			{+
−
			error = KErrNotFound;+
−
			aSelection.Delete(iOrigEntryPos);+
−
			}+
−
		else+
−
			{+
−
			// if the entry has children+
−
			CMsvEntrySelection* children = NULL;+
−
			TRAPD(err, children = new (ELeave)CMsvEntrySelection);+
−
			if(KErrNone != err)+
−
				{+
−
				return err;+
−
				}+
−
			TInt leave = KErrNone;+
−
			TRAP(leave, GetChildrenIdL(entryId, *children));+
−
			if(KErrNone != leave)+
−
				{+
−
				delete children;+
−
				return leave;				+
−
				}+
−
			TInt count = children->Count();+
−
			for(TInt index=0; index<count; ++index)+
−
				{+
−
				iRecursionIndex = iOrigEntryPos;+
−
				TRAP(leave, DoExpandSelectionRecursivelyL(children->At(index)));+
−
				if(KErrNone != leave)+
−
					{+
−
					delete children;+
−
					return leave;+
−
					}+
−
				}+
−
			delete children;	+
−
			++iOrigEntryPos;+
−
			}+
−
		}+
−
	return error;+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * DoExpandSelectionRecursivelyL+
−
 * Expands a selection to include all the descendents of the entry with TMsvId aId. +
−
 *+
−
 * @param aId TMsvId of the entire+
−
 * @return void+
−
 */+
−
void CMsvIndexAdapter::DoExpandSelectionRecursivelyL(TMsvId aId)+
−
	{+
−
	// include this entry+
−
	iRecursionSelection->InsertL(iRecursionIndex,aId);+
−
	iOrigEntryPos++;+
−
	+
−
	// if aEntry has children+
−
	CMsvEntrySelection* children = new (ELeave)CMsvEntrySelection;+
−
	CleanupStack::PushL(children);+
−
	+
−
	GetChildrenIdL(aId, *children);+
−
	+
−
	TInt count = children->Count();+
−
	for(TInt index=0; index<count; ++index)+
−
		{+
−
		DoExpandSelectionRecursivelyL(children->At(index));+
−
		}+
−
	+
−
	CleanupStack::PopAndDestroy(1, children);	//children+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * GetChildrenId()+
−
 * @param TMsvId: Id os the parent.+
−
 * @param CMsvEntrySelection: List of child Ids.+
−
 * +
−
 * This function should be used only by ExpandSelectionRecursively()+
−
 * and DoExpandSelectionRecursivelyL().+
−
 * --- 557 ---+
−
 * If aId is an standard id ensure that it is masked. If the aId is+
−
 * not masked the function will return children from current drive.+
−
 */+
−
void CMsvIndexAdapter::GetChildrenIdL(TMsvId aId, CMsvEntrySelection& aSelection)+
−
	{+
−
	CMsvCacheVisibleFolder* folderNode = NULL;	+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	if(IsStandardId(aId))+
−
		{+
−
		TUint driveId = GetDriveId(aId);+
−
		TMsvId unmaskedId = UnmaskTMsvId(aId);+
−
		+
−
		dqIter.SetToFirst();	+
−
		// Look for the entry in cache.+
−
		if(!iFolderListHeader.IsEmpty())+
−
			{+
−
			while(NULL != (folderNode = dqIter++))+
−
				{+
−
				if((unmaskedId == folderNode->GetFolderId()) && (driveId == folderNode->GetDrive()))+
−
					{+
−
					if(!folderNode->GetChildrenIdL(aSelection))+
−
						{+
−
						if(iDbAdapter)+
−
							{+
−
							iDbAdapter->GetChildrenIdL(aId, aSelection);+
−
							}+
−
						else+
−
							{+
−
							User::Leave(ErrorState());+
−
							}+
−
						}+
−
					return;+
−
					}+
−
				}+
−
			}+
−
		if(iDbAdapter)+
−
			{+
−
			iDbAdapter->GetChildrenIdL(aId, aSelection);+
−
			}+
−
		else+
−
			{+
−
			User::Leave(ErrorState());+
−
			}+
−
		return;+
−
		}+
−
#endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
	dqIter.SetToFirst();	+
−
	// Look for the entry in cache.+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		// Check if aId is one of the visible folder,+
−
		// already present in the cache.+
−
		while(NULL != (folderNode = dqIter++))+
−
			{+
−
			if(aId == folderNode->GetFolderId())+
−
				{+
−
				// Fetch children. Returns EFalse if unable+
−
				// to get them.+
−
				if(!folderNode->GetChildrenIdL(aSelection))+
−
					{+
−
					if(iDbAdapter)+
−
						{+
−
						// Childrens not fetched. Get them from DB.+
−
						iDbAdapter->GetChildrenIdL(aId, aSelection);+
−
						}+
−
					else+
−
						{+
−
						User::Leave(ErrorState());	+
−
						}+
−
					}+
−
				return;+
−
				}+
−
			}+
−
+
−
		// Entry is not present in the visibleFolder list.+
−
		CMsvCacheEntry* entry = NULL;+
−
		if(FindEntryInCache(aId, entry))+
−
			{+
−
			if(NULL != entry->ChildIdArray())+
−
				{+
−
				RArray<TMsvId>* childId = entry->ChildIdArray();+
−
				TInt size = childId->Count();+
−
				TInt index = 0;+
−
				while(index < size)+
−
					{+
−
					aSelection.AppendL((*childId)[index++]);+
−
					}+
−
				return;	+
−
				}+
−
			else+
−
				{+
−
				if(iDbAdapter)+
−
					{+
−
					iDbAdapter->GetChildrenIdL(aId, aSelection);+
−
					}+
−
				else+
−
					{+
−
					User::Leave(ErrorState());	+
−
					}+
−
				RArray<TMsvId>* childId = new(ELeave) RArray<TMsvId>;+
−
				TInt size = aSelection.Count();+
−
				TInt index = 0;+
−
				while(index < size)+
−
					{+
−
					TInt err = childId->Append(aSelection[index++]);+
−
					if(KErrNone != err)+
−
						{+
−
						childId->Reset();+
−
						childId->Close();+
−
						delete childId;+
−
						User::Leave(err);+
−
						}+
−
					}+
−
				entry->SetChildIdArray(childId);+
−
				return;+
−
				}+
−
			}+
−
		}+
−
	+
−
	// Could not find parent entry in cache.+
−
	// Check in DB now.	+
−
	if(iDbAdapter)+
−
		{+
−
		iDbAdapter->GetChildrenIdL(aId, aSelection);+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * ChangeEntry+
−
 * Change the contents of a TMsvEntry. +
−
 * +
−
 */+
−
TInt CMsvIndexAdapter::ChangeEntry(const TMsvEntry& aEntry, TSecureId aOwnerId, TBool aForcedUpdate)+
−
	{+
−
	TRAPD(err, DoChangeEntryL(aEntry, aOwnerId, EFalse, aForcedUpdate, ETrue));+
−
	return err;+
−
	}+
−
+
−
+
−
/**+
−
 * ChangeEntryNoCommit+
−
 */+
−
TInt CMsvIndexAdapter::ChangeEntryNoCommit(const TMsvEntry& aEntry, TSecureId aOwnerId, TBool aForcedUpdate)+
−
	{+
−
	if(!iDbAdapter)+
−
		{+
−
		return ErrorState();+
−
		}+
−
	+
−
	TRAP_IGNORE(iDbAdapter->BeginTransactionL());+
−
	TRAPD(err, DoChangeEntryL(aEntry, aOwnerId, EFalse, aForcedUpdate, EFalse));+
−
	if(err)+
−
		{+
−
		RollbackChanges();+
−
		}+
−
	return err;+
−
	}+
−
	+
−
+
−
/**+
−
 * ChangeEntryInternal()+
−
 */+
−
TInt CMsvIndexAdapter::ChangeEntryInternal(const TMsvEntry& aEntry, TSecureId aOwnerId)+
−
	{+
−
	TRAPD(err, DoChangeEntryL(aEntry, aOwnerId, ETrue, EFalse, ETrue));+
−
	return err;+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * DoChangeEntryL+
−
 */	+
−
void CMsvIndexAdapter::DoChangeEntryL(const TMsvEntry& aNewEntryContents, TSecureId aOwnerId, TBool aChangeStandardFolder, TBool aForcedUpdate, TBool aCommitToFile)+
−
    {+
−
    // Leave if the message store is not currently available+
−
    User::LeaveIfError(iErrorState);+
−
+
−
    // 1. Handle root entry differently.+
−
    if(aNewEntryContents.Id() == KMsvRootIndexEntryId)+
−
        {+
−
        TMsvEntry& entry = const_cast<TMsvEntry&> (aNewEntryContents);+
−
        iDbAdapter->UpdateEntryL(entry, KMsvRootIndexEntryId, EFalse);+
−
        iRootEntry->Entry() = entry;+
−
        return;+
−
        }+
−
+
−
    // 2. Find entry in cache.+
−
    CMsvCacheEntry* oldEntry = NULL;    +
−
    CMsvCacheVisibleFolder* oldFolderNode = NULL;+
−
    GetVisibleFolderDetailsL(aNewEntryContents.Id(), oldEntry, oldFolderNode);+
−
  +
−
    // 3. Validate entry.+
−
    // If the entry is not present in cache, it means it is not locked.+
−
    // Can only change a locked entry and not one marked as a standard +
−
    // folder unless aChangeStandardFolder is true.+
−
    if( (!oldEntry->IsEntryLocked()) || (aChangeStandardFolder==EFalse && oldEntry->Entry().StandardFolder()) )+
−
        {+
−
        User::Leave(KErrAccessDenied);+
−
        }+
−
+
−
    // Reserving space in changed entry list array.+
−
    if(!aCommitToFile)+
−
        {+
−
        iNonCommittedChangedEntryList.ReserveL(iNonCommittedChangedEntryList.Count()+1);+
−
        }+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
    // We do not support movement of entry to a folder present in a different drive.    +
−
    if( oldEntry->Entry().Parent() != KErrNotFound &&   //-1 will appear to be masked. disregard this.+
−
        GetDriveId(aNewEntryContents.Id()) != GetDriveId(oldEntry->Entry().Parent()))+
−
        {+
−
        User::Leave(KErrNotSupported);  +
−
        }+
−
#endif+
−
+
−
    TMsvId oldParentId = oldEntry->Entry().Parent();+
−
    TMsvId oldVisibleFolderId = oldFolderNode->GetFolderId();+
−
+
−
    // Check if the parent id is also changed.+
−
    CMsvCacheEntry* oldParentEntry = NULL;+
−
    CMsvCacheEntry* newParentEntry = NULL;+
−
    TBool resetOldParentOwnerFlag = EFalse;+
−
    CMsvEntrySelection* descendentList = NULL;+
−
    TMsvId newParentId = aNewEntryContents.Parent();+
−
    CMsvCacheVisibleFolder* newVisibleFolderNode = NULL;+
−
    if(oldParentId != newParentId)+
−
        {+
−
        // YES, PARENT ID IS CHANGED.+
−
        // These steps are similar to MoveEntry()+
−
        newVisibleFolderNode = DoChangeEntryPreambleL(oldEntry,+
−
                                                      newParentId,+
−
                                                      oldParentEntry,+
−
                                                      newParentEntry,+
−
                                                      oldVisibleFolderId,+
−
                                                      resetOldParentOwnerFlag,+
−
                                                      descendentList+
−
                                                     );+
−
        }   // if(oldParentId != newParentId)+
−
    TMsvId newVisibleFolderId = newVisibleFolderNode ? newVisibleFolderNode->GetFolderId() : oldVisibleFolderId;+
−
    // Update entry in cache.+
−
    TBool changedPrivateInfo;+
−
    CMsvCacheEntry* bkpEntry = NULL;+
−
    TRAPD(err, bkpEntry = iFreePoolInstance->EntryL();+
−
               bkpEntry->SetEntryL(oldEntry->Entry());+
−
               bkpEntry->SetEntryOwnerId(oldEntry->EntryOwnerId());+
−
               oldEntry->CopyEntryL(aNewEntryContents, changedPrivateInfo);+
−
         );+
−
    if(err)+
−
        {+
−
        iFreePoolInstance->ReleaseEntryWithoutTransaction(bkpEntry);+
−
        if(newVisibleFolderNode)+
−
            newVisibleFolderNode->DeleteEntryL(oldEntry->GetId());+
−
        User::Leave(err);+
−
        }+
−
    UpdateDates(*oldEntry, EFalse);+
−
    +
−
    if(aForcedUpdate || changedPrivateInfo && aOwnerId != KMsvServerId )+
−
        {+
−
        oldEntry->SetEntryOwnerId(aOwnerId);+
−
        }+
−
+
−
    TRAP(err, +
−
            if(aCommitToFile)+
−
                iDbAdapter->BeginTransactionL();+
−
            // Update the actual entry+
−
            if(oldParentId != newParentId)+
−
                {+
−
                iDbAdapter->UpdateEntryL(oldEntry->Entry(), newVisibleFolderId);+
−
                }+
−
            else+
−
                {+
−
                iDbAdapter->UpdateEntryL(oldEntry->Entry(), newVisibleFolderId, EFalse);+
−
                }+
−
            // Reset old parent owner flag.+
−
            if(resetOldParentOwnerFlag)+
−
                iDbAdapter->UpdateOwnerStatusL(oldParentId, oldParentEntry->Entry(), EFalse);+
−
            // Set new parent owner flag.+
−
            if(newParentEntry && (!newParentEntry->Entry().Owner()))+
−
                iDbAdapter->UpdateOwnerStatusL(newParentId, newParentEntry->Entry(), ETrue);+
−
            // Update the child entries visibleFolderId in DB.+
−
            if(descendentList)+
−
                iDbAdapter->UpdateVisibleFolderL(descendentList, newVisibleFolderId);+
−
            if(aCommitToFile)+
−
                iDbAdapter->CommitTransactionL();+
−
         );+
−
    if(err)+
−
        {+
−
        if(aCommitToFile)+
−
            TRAP_IGNORE(iDbAdapter->RollbackTransactionL());+
−
        oldEntry->SetEntryOwnerId(bkpEntry->EntryOwnerId());+
−
        oldEntry->CopyEntryL(bkpEntry->Entry(), changedPrivateInfo);+
−
        iFreePoolInstance->ReleaseEntryWithoutTransaction(bkpEntry);+
−
        if(newVisibleFolderNode)    +
−
            newVisibleFolderNode->DeleteEntryL(oldEntry->GetId());+
−
        User::Leave(err);+
−
        }+
−
    // Nothing should fail after this. Ensure that +
−
    // all leaving function after this does not leave.+
−
    if(aCommitToFile)+
−
        {+
−
        iFreePoolInstance->ReleaseEntryWithoutTransaction(bkpEntry);+
−
        DoChangeEntryPostamble(oldFolderNode, newVisibleFolderId, oldEntry->GetId(), descendentList, newParentEntry, oldParentEntry, resetOldParentOwnerFlag);+
−
        if(descendentList)+
−
            {+
−
            CleanupStack::PopAndDestroy(descendentList);+
−
            }+
−
        }   // if(aCommitToFile)+
−
    else+
−
        {+
−
        // Store relevant data for later commit.+
−
        TNonCommittedChangedEntries entryDetails(oldFolderNode, +
−
                                                 newVisibleFolderNode, +
−
                                                 oldEntry,+
−
                                                 bkpEntry,+
−
                                                 oldParentEntry, +
−
                                                 newParentEntry,+
−
                                                 descendentList,+
−
                                                 resetOldParentOwnerFlag);+
−
        iNonCommittedChangedEntryList.Append(entryDetails);+
−
        if(descendentList)+
−
            CleanupStack::Pop(descendentList);+
−
        }+
−
+
−
    // Update entry in SearchSort delta cache.+
−
    if(aNewEntryContents.iType.iUid == KUidMsvMessageEntryValue && CMSvSearchSortCacheManager::Instance()->iManagerEntry != NULL)+
−
        {+
−
        TMsgType aType(EUpdatedMsg);+
−
        if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0)+
−
            {+
−
            CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aNewEntryContents.Id(), aType);+
−
            }+
−
        }+
−
    }+
−
+
−
+
−
+
−
// Used only by DoChangeEntryL()+
−
CMsvCacheVisibleFolder* CMsvIndexAdapter::DoChangeEntryPreambleL(CMsvCacheEntry*& aOldEntry, TMsvId aNewParentId, CMsvCacheEntry*& aOldParentEntry, CMsvCacheEntry*& aNewParentEntry, TMsvId aOldVisibleFolderId, TBool& aResetOldParentOwnerFlag, CMsvEntrySelection*& aDescendentList)+
−
    {+
−
    // YES, PARENT ID IS CHANGED.+
−
    // These steps are similar to MoveEntry()+
−
    TBool des;+
−
    IsADescendent(aOldEntry->Entry().Id(), aNewParentId, des);+
−
    if (des)+
−
        {+
−
        User::Leave(KErrArgument);+
−
        }+
−
   +
−
    // Fetch the parent entries.    +
−
    FindEntryL(aOldEntry->Entry().Parent(), aOldParentEntry);+
−
    FindEntryL(aNewParentId, aNewParentEntry);+
−
+
−
    // Check if the owner flag of the old parent needs to be reset.    +
−
    CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;+
−
    CleanupStack::PushL(children);+
−
    GetChildrenIdL(aOldEntry->Entry().Parent(), *children);+
−
    if(1 == children->Count() && aOldParentEntry->Entry().Owner())+
−
        {+
−
        aResetOldParentOwnerFlag = ETrue;+
−
        }+
−
    CleanupStack::PopAndDestroy(); //children+
−
    +
−
    // If required, pre-allocate memory for child array of newParentEntry.+
−
    if(aNewParentEntry->ChildIdArray())+
−
        {+
−
        // This to ensure that future append does not fail.+
−
        aNewParentEntry->ChildIdArray()->ReserveL(aNewParentEntry->ChildIdArray()->Count() + 1);+
−
        }+
−
+
−
    // Find the visibleFolder of new parent. +
−
    TMsvId newVisibleFolderId = NULL;+
−
    if(!GetVisibleFolderId(aNewParentId, newVisibleFolderId))+
−
         {+
−
         User::Leave(KErrNotFound);+
−
         }+
−
+
−
    // Check if the visible folders are different.+
−
    CMsvCacheVisibleFolder* newVisibleFolderNode = NULL;+
−
    if(aOldVisibleFolderId != newVisibleFolderId)+
−
        {+
−
        // If the visible folders are different, check if+
−
        // child entries also needs to be moved.+
−
        if(!aOldEntry->Entry().VisibleFolderFlag())+
−
            {+
−
            // If yes, create a descendent list of the entry.+
−
            aDescendentList = new(ELeave) CMsvEntrySelection;+
−
            CleanupStack::PushL(aDescendentList);+
−
            aDescendentList->AppendL(aOldEntry->GetId());+
−
            User::LeaveIfError(ExpandSelectionRecursively(*aDescendentList));+
−
            }+
−
        +
−
        // Add duplicate entry under new visible folder. Removing +
−
        // entry from old visible folder is done later.+
−
        CMsvCacheEntry* newCacheEntry = iFreePoolInstance->EntryL();+
−
        TRAPD(err, newCacheEntry->DupNDestroyL(aOldEntry);+
−
                   newVisibleFolderNode = AddEntryToCacheL(newVisibleFolderId, newCacheEntry);+
−
             );+
−
        if(err)+
−
            {+
−
            iFreePoolInstance->ReleaseEntryWithoutTransaction(newCacheEntry);+
−
            User::Leave(err);+
−
            }+
−
        aOldEntry = newCacheEntry;+
−
        }   // if(oldVisibleFolderId != newVisibleFolderId)    }+
−
    return newVisibleFolderNode;+
−
    }+
−
+
−
+
−
+
−
// Used only by DoChangeEntryL()+
−
void CMsvIndexAdapter::DoChangeEntryPostamble(CMsvCacheVisibleFolder* aOldFolderNode, TMsvId aNewVisibleFolderId, TMsvId aEntryId, CMsvEntrySelection* aDescendentList, CMsvCacheEntry* aNewParentEntry, CMsvCacheEntry* aOldParentEntry, TBool aResetOldParentOwnerFlag)+
−
    {+
−
     // Removing entry from old visible folder.+
−
     if(aOldFolderNode->GetFolderId() != aNewVisibleFolderId)+
−
         {+
−
         // Will never leave.+
−
         //aOldFolderNode->DeleteEntryL(oldEntry->GetId());+
−
         TRAP_IGNORE(aOldFolderNode->DeleteEntryL(aEntryId));+
−
         }+
−
     +
−
     // Removing child entries from old visible folder.+
−
     if(aDescendentList)+
−
         {+
−
         for(TInt index=(aDescendentList->Count()-2); index>=0; index--)+
−
             {+
−
             // Can leave with KErrNotFound.+
−
             TRAP_IGNORE(aOldFolderNode->DeleteEntryL(aDescendentList->At(index)));+
−
             }         +
−
         }+
−
    +
−
     // Add child id to new parent child array.+
−
     if(aNewParentEntry && aNewParentEntry->ChildIdArray())+
−
         {+
−
         // This will not leave, as memory is already reserved.+
−
         TRAP_IGNORE(aNewParentEntry->ChildIdArray()->AppendL(aEntryId));+
−
         }+
−
     +
−
     // Remove child from old parent's child array.+
−
     if(aOldParentEntry)+
−
         {+
−
         RArray<TMsvId>* oldParentChildArr = aOldParentEntry->ChildIdArray();+
−
         if(oldParentChildArr)+
−
             {+
−
             TInt pos = oldParentChildArr->Find(aEntryId);+
−
             if(pos != KErrNotFound)+
−
                 {+
−
                 oldParentChildArr->Remove(pos);+
−
                 }+
−
             }+
−
         }+
−
    +
−
     // Update owner flag of parent entries.+
−
     if(aResetOldParentOwnerFlag)+
−
         {+
−
         aOldParentEntry->Entry().SetOwner(EFalse);+
−
         }+
−
     if(aNewParentEntry)+
−
         {+
−
         aNewParentEntry->Entry().SetOwner(ETrue);+
−
         }+
−
 }+
−
 +
−
 +
−
 +
−
 +
−
/**+
−
 * GetEntry()+
−
 */+
−
TInt CMsvIndexAdapter::GetEntry(TMsvId aId, TMsvEntry*& aEntry) +
−
	{+
−
	TSecureId dummy;+
−
	return GetEntry(aId, aEntry, dummy);+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * GetEntryNoCache()+
−
 * If aAddToCache is EFalse, entry will not be added to cache,+
−
 * if the entry is fetched from DB. The user of this function+
−
 * should ensure that it releses the memory occupied by entry+
−
 * to the freepool.+
−
 */+
−
TInt CMsvIndexAdapter::GetEntryNoCache(TMsvId aId, TMsvEntry* aEntry)+
−
	{+
−
	if(KMsvRootIndexEntryId == aId)+
−
		{+
−
		*aEntry = iRootEntry->Entry();				+
−
		return KErrNone;+
−
		}+
−
+
−
	TBool aIsDanglingEntry = EFalse;+
−
	CMsvCacheEntry* serverEntry=NULL;+
−
	TRAPD(err, aIsDanglingEntry = FindEntryL(aId, serverEntry, EFalse));+
−
+
−
	if (err == KErrNone)+
−
		{+
−
		*aEntry = serverEntry->Entry();+
−
		// If entry is not present in cache,+
−
		// it should be handled carefully.+
−
		if(aIsDanglingEntry)+
−
			{+
−
			// Release CMsvCacheEntry to freepool.+
−
			iFreePoolInstance->ReleaseEntry(serverEntry, ETrue);+
−
			}		+
−
		return KErrNone;	+
−
		}+
−
	else+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	}+
−
+
−
+
−
+
−
	+
−
/**+
−
 * GetEntry()+
−
 */+
−
TInt CMsvIndexAdapter::GetEntry(TMsvId aId, TMsvEntry*& aEntry, TSecureId& aOwnerId) +
−
	{+
−
	if(KMsvRootIndexEntryId == aId)+
−
		{+
−
		aEntry = &iRootEntry->Entry();+
−
		aOwnerId = 0;+
−
		return KErrNone;+
−
		}+
−
+
−
	CMsvCacheEntry* serverEntry=NULL;+
−
	TRAPD(err, FindEntryL(aId, serverEntry));	+
−
+
−
	if (err == KErrNone)+
−
		{+
−
		aEntry = &serverEntry->Entry();+
−
		aOwnerId = serverEntry->EntryOwnerId();+
−
		return KErrNone;	+
−
		}+
−
	else+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	}+
−
	+
−
+
−
+
−
/**+
−
 * FindEntryInCache()+
−
 * @param aId: Entry Id.+
−
 * @return aEntry: CMsvCacheEntry+
−
 * @return bool: ETrue if entry found, otherwise EFalse.+
−
 * +
−
 * Find an entry only in cache and return the entry.+
−
 */+
−
TBool CMsvIndexAdapter::FindEntryInCache(TMsvId aId, CMsvCacheEntry*& aEntry) +
−
	{+
−
	if(KMsvRootIndexEntryId == aId)+
−
		{+
−
		aEntry = iRootEntry;+
−
		return ETrue;+
−
		}+
−
+
−
	// If cache is not empty.+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		CMsvCacheVisibleFolder* folderNode = NULL;+
−
		TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
		dqIter.SetToFirst(); +
−
		+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			if(folderNode->GetEntry(aId, aEntry))+
−
				{+
−
				return ETrue;+
−
				}+
−
			}+
−
		}+
−
	aEntry = NULL;+
−
	return EFalse;+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * FindEntryL()+
−
 * +
−
 * WARNING:+
−
 * Returns CMsvCacheEntry which is still owned by Cache. so aEntry should+
−
 * never be deleted by the caller.+
−
 *+
−
 * If the entry is fetched from DB and not added to cache, the function +
−
 * returns ETrue, indicating that aEntry should be release to the freepool+
−
 * by the caller.+
−
 */+
−
TBool CMsvIndexAdapter::FindEntryL(TMsvId aId, CMsvCacheEntry*& aEntry, TBool aAddToCache /*DEFAULT=ETrue */)+
−
	{+
−
	// First search the entry in cache, +
−
	if(FindEntryInCache(aId, aEntry))+
−
		{+
−
		return EFalse;+
−
		}	+
−
+
−
	// Entry cannot be found in cache,+
−
	// Now search in DB.+
−
	TMsvId visibleEntryId;+
−
	if(iDbAdapter)+
−
		{+
−
		iDbAdapter->GetEntryL(aId, aEntry, visibleEntryId);+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
+
−
	if(aAddToCache)	+
−
		{+
−
		// Add entry to cache.+
−
		AddEntryToCacheL(visibleEntryId, aEntry);	+
−
		}+
−
	else+
−
		{+
−
		// If the entry is not added to cache, we need not start +
−
		// the background operation. We can return ETrue saying+
−
		// entry is dangling and needs to be freed.+
−
		return ETrue;+
−
		}+
−
	if (!iIdle->IsActive())+
−
		{+
−
		iIdle->Start(TCallBack(BackGroundOperations, this));+
−
		}+
−
	return EFalse;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * AddEntryNoVisibleL()+
−
 */+
−
void CMsvIndexAdapter::AddEntryNoVisibleL(CMsvCacheEntry* aEntry)+
−
	{+
−
	TMsvId visibleFolder;+
−
	if(GetVisibleFolderId(aEntry->Entry().Parent(), visibleFolder))	+
−
		{+
−
		AddEntryToCacheL(visibleFolder, aEntry);+
−
		}+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * AddEntryToCacheL()+
−
 */+
−
CMsvCacheVisibleFolder* CMsvIndexAdapter::AddEntryToCacheL(TMsvId aVisibleEntryId, CMsvCacheEntry* aEntry)+
−
	{+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	TUint driveId = GetDriveId(aEntry->GetId());+
−
	if(IsStandardId(aEntry->GetId()))+
−
		{+
−
		aEntry->Entry().SetId(UnmaskTMsvId(aEntry->GetId()));+
−
		}+
−
#endif+
−
	// First search the visibleEntry in cache, +
−
	// if cache is not empty...+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		CMsvCacheVisibleFolder* folderNode = NULL;+
−
		TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
		dqIter.SetToFirst();+
−
		+
−
		while((folderNode =  dqIter++)!=NULL)+
−
			{+
−
			TMsvId folderId = folderNode->GetFolderId();+
−
			if(aVisibleEntryId == folderId)+
−
				{+
−
				// Visible folder exists.+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
				// For standard entries also check for driveId.+
−
				if(IsStandardId(aVisibleEntryId))+
−
					{+
−
					if(driveId == folderNode->GetDrive())+
−
						{+
−
						folderNode->AddEntryL(aEntry);+
−
						return folderNode;+
−
						}+
−
					}+
−
				else+
−
#endif+
−
					{+
−
					// Add entry to this folder.+
−
					folderNode->AddEntryL(aEntry);+
−
					return folderNode;+
−
					}+
−
				}+
−
			}+
−
		}+
−
+
−
	// Visible folder not found in the folder list.+
−
	// Create the visible folder and add it to the+
−
	// beginning of the list.+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	CMsvCacheVisibleFolder* newFolder = CMsvCacheVisibleFolder::NewL(MaskTMsvId(GetDriveId(aEntry->GetId()), aVisibleEntryId));+
−
#else+
−
	CMsvCacheVisibleFolder* newFolder = CMsvCacheVisibleFolder::NewL(aVisibleEntryId);+
−
#endif+
−
	iFolderListHeader.AddFirst(*newFolder);+
−
	+
−
	// Now add entry to the visible folder+
−
	newFolder->AddEntryL(aEntry);+
−
	return newFolder;+
−
	}+
−
	+
−
+
−
+
−
/**+
−
 * GetChildrenL()+
−
 */+
−
void CMsvIndexAdapter::GetChildrenL(TMsvId aId, CArrayPtr<const TMsvEntry>& aSelection, const TMsvSelectionOrdering& aOrdering, TUid aMtm)+
−
	{+
−
	TSecureId dummy = KMsvServerId.iId;+
−
	GetChildrenL(aId, aSelection, aOrdering, aMtm, EFalse, dummy);+
−
	}+
−
+
−
+
−
	+
−
/**+
−
 * GetChildrenL()+
−
 */+
−
void CMsvIndexAdapter::GetChildrenL(TMsvId aId, CArrayPtr<const TMsvEntry>& aSelection, const TMsvSelectionOrdering& aOrdering, TUid aMtm, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	CMsvEntryFilter* filter = CMsvEntryFilter::NewLC();+
−
	filter->SetOrder(aOrdering);+
−
	filter->SetSortMtm(aMtm);+
−
	CMsvEntryArray* entries = DoGetChildrenL(aId, *filter, aFilterByOwnerId, aOwnerId);	+
−
	CleanupStack::PushL(entries);	+
−
	+
−
	TInt count = entries->Count();+
−
	for (TInt ii=0; ii<count; ii++)+
−
		{+
−
		aSelection.AppendL(entries->At(ii));+
−
		}+
−
	CleanupStack::PopAndDestroy(2, filter); // filter and entries+
−
	}+
−
+
−
+
−
+
−
	+
−
/**+
−
 * DoGetChildrenL+
−
 */	+
−
CMsvEntryArray* CMsvIndexAdapter::DoGetChildrenL(TMsvId aId, const CMsvEntryFilter& aFilter, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	// Check if entry for aId exists...+
−
	CMsvCacheEntry* entry=NULL;+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	TUint driveId = GetDriveId(aId);+
−
	TMsvId unmaskedId = UnmaskTMsvId(aId);+
−
	if(IsStandardId(aId))+
−
		{		+
−
		FindEntryL(unmaskedId, entry);+
−
		}+
−
	else+
−
#endif+
−
		{+
−
		FindEntryL(aId, entry);+
−
		}+
−
+
−
	TBool isParentAVisibleFolder = EFalse;+
−
	if(entry->Entry().VisibleFolderFlag())+
−
		{+
−
		isParentAVisibleFolder = ETrue;+
−
		}+
−
+
−
	CArrayFixFlat<TUid>* mtmList = new(ELeave) CArrayFixFlat<TUid>(KMsvMtmListGranularity);+
−
	CleanupStack::PushL(mtmList);+
−
	if (KUidMsvNullEntry != aFilter.SortMtm())+
−
		{+
−
		mtmList->AppendL(aFilter.SortMtm());+
−
		}+
−
+
−
	RPointerArray<CMsvCacheEntry> selection;+
−
	CleanupClosePushL(selection);+
−
	+
−
	CMsvCacheVisibleFolder* folderNode = NULL;	+
−
	CMsvEntryArray* entries = CMsvEntryArray::NewLC(*mtmList);+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
	if(IsStandardId(aId))+
−
		{+
−
		// Look for the entry in cache.+
−
		if(!iFolderListHeader.IsEmpty())+
−
			{+
−
			dqIter.SetToFirst(); +
−
			// Check if aId is one of the visible folder,+
−
			// already present in the cache.+
−
			while(NULL != (folderNode = dqIter++))+
−
				{+
−
				if((folderNode->GetFolderId() == unmaskedId) && (folderNode->GetDrive() == driveId))+
−
					{+
−
					folderNode->GetChildrenL(aId, iDbAdapter, selection);+
−
					FilterChildrenListL(aId, selection, *entries, aFilter, aFilterByOwnerId, aOwnerId);+
−
					CleanupStack::Pop(entries);	// Fetch entries from stack. It will be destroyed by caller.+
−
					CleanupStack::PopAndDestroy(2);+
−
					return entries;+
−
					}+
−
				}+
−
			}+
−
		}+
−
	else+
−
		{				+
−
#endif			// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
	// Look for the entry in cache.+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		dqIter.SetToFirst(); +
−
		// Check if aId is one of the visible folder,+
−
		// already present in the cache.+
−
		while(NULL != (folderNode = dqIter++))+
−
			{+
−
			if(aId == folderNode->GetFolderId())+
−
				{+
−
				if(iDbAdapter == NULL)+
−
					{+
−
					User::Leave(ErrorState());	+
−
					}+
−
				folderNode->GetChildrenL(aId, iDbAdapter, selection);+
−
				FilterChildrenListL(aId, selection, *entries, aFilter, aFilterByOwnerId, aOwnerId);+
−
				CleanupStack::Pop(entries);	// Fetch entries from stack. It will be destroyed by caller.+
−
				CleanupStack::PopAndDestroy(2);+
−
				return entries;+
−
				}+
−
			}+
−
+
−
		// If the parent is not a visible folder+
−
		// check if it is child of one of the visible folder.+
−
		if(EFalse == isParentAVisibleFolder)+
−
			{+
−
			dqIter.SetToFirst(); +
−
			while(NULL != (folderNode = dqIter++))+
−
				{+
−
				TBool retVal=EFalse;+
−
				TRAPD(err, retVal = folderNode->GetChildrenL(aId, iDbAdapter, selection))+
−
+
−
				// aId not found under current visibleFolder.+
−
				if(KErrNotFound == err)+
−
					{+
−
					continue;+
−
					}+
−
				+
−
				// aId found under current visibleFolder.+
−
				if(retVal)+
−
					{+
−
					// Children is fetched succesfully.+
−
					FilterChildrenListL(aId, selection, *entries, aFilter, aFilterByOwnerId, aOwnerId);	+
−
					CleanupStack::Pop(entries);  // Fetch entries from stack. It will be destroyed by caller.+
−
					CleanupStack::PopAndDestroy(2);+
−
					return entries;+
−
					}+
−
				else+
−
					{+
−
					// aId itself is a visibleFolder.+
−
					isParentAVisibleFolder = ETrue;+
−
					break;+
−
					}+
−
				}+
−
			}+
−
		}+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
		}+
−
#endif			// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
		+
−
	// Could not find parent entry in cache.+
−
	// Check in DB now.	+
−
	TInt err = KErrNone;+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP(err, iDbAdapter->GetChildrenL(aId, selection));+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
	if(err)+
−
		{+
−
		User::Leave(KErrNotFound);+
−
		}+
−
	FilterChildrenListL(aId, selection, *entries, aFilter, aFilterByOwnerId, aOwnerId);+
−
	+
−
	// Check if the entire entry list can be added to cache.+
−
	// This is important in a situation when all childs of a +
−
	// folder cannot be accomodated in cache. In such scenario+
−
	// only entries with higher TMsvId will be added to cache.+
−
	TInt excessEntries = iFreePoolInstance->ExcessMemoryAllocated();+
−
	TBool isCompleteChildren = ETrue;+
−
	if(excessEntries)+
−
		{+
−
		isCompleteChildren = EFalse;+
−
		}+
−
	while(excessEntries)+
−
		{+
−
		if(selection.Count())+
−
			{+
−
			iFreePoolInstance->RecordExcessMemoryL(selection[0]);+
−
			selection.Remove(0);+
−
			}+
−
		--excessEntries;+
−
		}		+
−
+
−
	// Add children to cache.+
−
	TMsvId visibleFolderId;+
−
	if(!isParentAVisibleFolder)+
−
		{+
−
		if(!GetVisibleFolderId(aId, visibleFolderId))+
−
			{+
−
			User::Leave(KErrNotFound);+
−
			}+
−
		}+
−
	else+
−
		{+
−
		visibleFolderId = aId;+
−
		}+
−
	+
−
	TBool isEntryAdded = EFalse;		+
−
	dqIter.SetToFirst();+
−
	while((folderNode = dqIter++)!=NULL)+
−
		{+
−
		if(visibleFolderId == folderNode->GetFolderId())+
−
			{+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
			if(IsStandardId(visibleFolderId))+
−
				{+
−
				if(GetDriveId(aId) == folderNode->GetDrive())+
−
					{+
−
					isEntryAdded=ETrue;+
−
					folderNode->AddEntryListL(selection, (isCompleteChildren && isParentAVisibleFolder));+
−
					}+
−
				}+
−
			else+
−
#endif+
−
				{+
−
				isEntryAdded=ETrue;+
−
				folderNode->AddEntryListL(selection, (isCompleteChildren && isParentAVisibleFolder));+
−
				}+
−
			}+
−
		}+
−
	+
−
	if(!isEntryAdded)+
−
		{+
−
		// If aId is the visibleFolder itself then pass+
−
		// aIsCompleteChildOfFolder as ETrue.+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
		// Standard Id can be unmasked.+
−
		CMsvCacheVisibleFolder* newFolder = CMsvCacheVisibleFolder::NewL(MaskTMsvId(GetDriveId(aId), visibleFolderId));+
−
#else+
−
		CMsvCacheVisibleFolder* newFolder = CMsvCacheVisibleFolder::NewL(visibleFolderId);+
−
#endif	+
−
		iFolderListHeader.AddFirst(*newFolder);+
−
		newFolder->AddEntryListL(selection, (isCompleteChildren && isParentAVisibleFolder));+
−
		}+
−
+
−
	CleanupStack::Pop(entries);		// Fetch entries from stack. It will be destroyed by caller.+
−
	CleanupStack::PopAndDestroy(2);+
−
	+
−
	//Start the background operations, if not running.+
−
	if (!iIdle->IsActive())+
−
		{+
−
		iIdle->Start(TCallBack(BackGroundOperations, this));+
−
		}+
−
		+
−
	return entries;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * GetChildrenId()+
−
 */+
−
TInt CMsvIndexAdapter::GetChildrenId(TMsvId aId, const CMsvEntryFilter& aFilter, CMsvEntrySelection& aSelection)+
−
	{+
−
	TSecureId dummy = KMsvServerId.iId;+
−
	return GetChildrenId(aId, aFilter, aSelection, EFalse, dummy);+
−
	}+
−
	+
−
/**+
−
 * GetChildrenId()+
−
 */+
−
TInt CMsvIndexAdapter::GetChildrenId(TMsvId aId, const CMsvEntryFilter& aFilter, CMsvEntrySelection& aSelection, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	CMsvEntryArray* entries = NULL;+
−
	TInt err = KErrNone;+
−
	TRAP(err, entries=DoGetChildrenL(aId, aFilter, aFilterByOwnerId, aOwnerId));+
−
	if(err)+
−
		{+
−
		delete entries;+
−
		return err;+
−
		}+
−
+
−
	TInt count = entries->Count();+
−
	for(TInt i=0; i<count; ++i)+
−
		{+
−
		TRAP(err, aSelection.AppendL(entries->At(i)->Id()));+
−
		}+
−
	delete entries;+
−
	return err;+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * FilterChildrenListL+
−
 */	+
−
void CMsvIndexAdapter::FilterChildrenListL(TMsvId aId, RPointerArray<CMsvCacheEntry> aChacheEntry, CMsvEntryArray& aEntryArray, const CMsvEntryFilter& aFilter, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	TBool getInvisibleEntries = aFilter.Order().ShowInvisibleEntries();+
−
	TInt count = aChacheEntry.Count();+
−
	for(TInt i=0; i<count; ++i)+
−
		{+
−
		TMsvEntry entry = aChacheEntry[i]->Entry();+
−
		TBool vis = aChacheEntry[i]->Entry().Visible();+
−
		if ((aChacheEntry[i]->Entry().Visible() || getInvisibleEntries) &&+
−
			(aFilter.Service() == KMsvNullIndexEntryId || aChacheEntry[i]->Entry().iServiceId == aFilter.Service()) &&+
−
			(aFilter.Mtm() == KNullUid || aChacheEntry[i]->Entry().iMtm == aFilter.Mtm()) &&+
−
			(aFilter.Type() == KNullUid || aChacheEntry[i]->Entry().iType == aFilter.Type()) &&+
−
			(aFilter.LastChangeDate().Int64() == 0 || aChacheEntry[i]->LastChangeDate() >= aFilter.LastChangeDate()))+
−
			{+
−
			// Add the entry if - +
−
			// 1. Not filtering by owner ID OR+
−
			// 2. Filtering by owner ID, but entry owner ID matches OR+
−
			// 3. Entry is a standard folder OR+
−
			// 4. Entrt is a service entry.+
−
			if( !aFilterByOwnerId || +
−
					aChacheEntry[i]->EntryOwnerId() == aOwnerId ||+
−
					aChacheEntry[i]->Entry().StandardFolder() || +
−
					aChacheEntry[i]->Entry().iType == KUidMsvServiceEntry )+
−
				{+
−
				aEntryArray.AppendL(&aChacheEntry[i]->Entry());+
−
				}+
−
			}+
−
		}+
−
	+
−
	if (aEntryArray.Count())+
−
		{+
−
		if (aId==KMsvRootIndexEntryId)+
−
			{+
−
			aEntryArray.SortL(TMsvSelectionOrdering(KMsvNoGrouping, aFilter.Order().Sorting()));	+
−
			}+
−
		else+
−
			{+
−
			aEntryArray.SortL(aFilter.Order());	+
−
			}+
−
		}	+
−
	}+
−
+
−
+
−
+
−
+
−
/** +
−
 * LockEntry()+
−
 */+
−
TInt CMsvIndexAdapter::LockEntry(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry))+
−
	if (err)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	+
−
	return entry->LockEntry();+
−
	}+
−
		+
−
+
−
+
−
/**+
−
 * ReleaseEntry()+
−
 */+
−
TInt CMsvIndexAdapter::ReleaseEntry(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		entry->ReleaseEntry();+
−
		return KErrNone;+
−
		}+
−
	else+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	}+
−
	+
−
	+
−
+
−
+
−
/**+
−
 * IsEntryLocked()+
−
 */+
−
TInt CMsvIndexAdapter::IsEntryLocked(TMsvId aId, TBool& aLocked)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if(KErrNone != err)+
−
		{+
−
		aLocked = EFalse;+
−
		return err;+
−
		}+
−
	+
−
	aLocked = entry->IsEntryLocked();+
−
	return KErrNone;+
−
	}+
−
	+
−
	+
−
+
−
+
−
+
−
/**+
−
 * LockStore()+
−
 */+
−
TInt CMsvIndexAdapter::LockStore(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if (err)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	+
−
	return entry->LockStore();+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * ReleaseStore()+
−
 */+
−
TInt CMsvIndexAdapter::ReleaseStore(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		entry->ReleaseStore();+
−
		return KErrNone;+
−
		}+
−
	else+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * IsStoreLocked()+
−
 */+
−
TInt CMsvIndexAdapter::IsStoreLocked(TMsvId aId, TBool& aLocked)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if(KErrNone != err)+
−
		{+
−
		aLocked = EFalse;+
−
		return err;+
−
		}+
−
	aLocked = entry->IsStoreLocked();+
−
	return KErrNone;+
−
	}+
−
+
−
+
−
+
−
	+
−
/**+
−
 * IsEntryAndStoreLocked()+
−
 */+
−
TInt CMsvIndexAdapter::IsEntryOrStoreLocked(TMsvId aId)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	TBool locked = EFalse;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		locked = entry->IsEntryOrStoreLocked();+
−
		}+
−
	if(locked)+
−
		{+
−
		return KErrLocked;+
−
		}+
−
	else+
−
		{+
−
		return KErrNone;+
−
		}+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * LockEntryAndStore()+
−
 */+
−
TInt CMsvIndexAdapter::LockEntryAndStore(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if (err)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
		+
−
	return entry->LockEntryAndStore();+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * ReleaseEntryAndStore()+
−
 */+
−
TInt CMsvIndexAdapter::ReleaseEntryAndStore(TMsvId aId)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		entry->ReleaseEntryAndStore();+
−
		return KErrNone;+
−
		}+
−
	else+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * IsEntryOrStoreLocked()+
−
 */+
−
TInt CMsvIndexAdapter::IsEntryOrStoreLocked(TMsvId aId, TBool& aLocked)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		aLocked = entry->IsEntryOrStoreLocked();+
−
		}+
−
	else+
−
		{+
−
		aLocked = EFalse;+
−
		}+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * IsStoreReadingLocked()+
−
 */+
−
TInt CMsvIndexAdapter::IsStoreReadingLocked(TMsvId aId, TBool& aLocked)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		aLocked = entry->IsStoreReadingLocked();+
−
		}+
−
	else+
−
		{+
−
		aLocked = EFalse;+
−
		}+
−
	return KErrNone;	+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * IncStoreReaderCount()+
−
 */+
−
TInt CMsvIndexAdapter::IncStoreReaderCount(TMsvId aId)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if (err)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
		+
−
	entry->IncStoreReaderCount();+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * DecStoreReaderCount()+
−
 */+
−
TInt CMsvIndexAdapter::DecStoreReaderCount(TMsvId aId)+
−
	{+
−
	CMsvCacheEntry* entry = NULL;+
−
	if(FindEntryInCache(aId, entry))+
−
		{+
−
		entry->DecStoreReaderCount();+
−
		}+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * OwningService()+
−
 */+
−
TInt CMsvIndexAdapter::OwningService(TMsvId aId, TMsvId& aService)+
−
	{    +
−
	aService = aId;+
−
	if (aId!=KMsvRootIndexEntryId)+
−
		{+
−
		FOREVER+
−
			{+
−
			CMsvCacheEntry* entry = NULL;	+
−
			TRAPD(err, FindEntryL(aService, entry));+
−
			if (err)+
−
				{+
−
				return KErrNotFound;+
−
				}+
−
+
−
			if (KUidMsvServiceEntry==entry->Entry().iType)+
−
				{+
−
				break;+
−
				}+
−
			aService = entry->Entry().Parent();+
−
			}+
−
		}+
−
+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * IsLocal()+
−
 */+
−
TInt CMsvIndexAdapter::IsLocal(TMsvId aId, TBool& aLocal)+
−
	{+
−
	TInt errVal = KErrNone;+
−
	aLocal = ETrue;+
−
	+
−
	if (aId!=KMsvRootIndexEntryId)+
−
		{+
−
		TMsvId service;+
−
		errVal = OwningService(aId, service);+
−
		aLocal = (KMsvLocalServiceIndexEntryId==service);+
−
		}+
−
		+
−
	return errVal;+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * MoveEntry+
−
 * Moves a entry with TMsvId as aId to a folder with target id as aTarget+
−
 * +
−
 * @param aId TMsvId of the entry to be moved.+
−
 * @param aTarget TMsvId of the parent folder.+
−
 * @param aDescendents List of descendents id, if the caller also wants to move descendents+
−
 * in cache and DB. The last id in the descendent list must be the entry id itself.+
−
 * @return TInt System-wide error code.+
−
 */+
−
TInt CMsvIndexAdapter::MoveEntry(TMsvId aId, TMsvId aTarget, CMsvEntrySelection* aDescendents /* DEFAULT=NULL */)+
−
	{+
−
	TRAPD(err, DoMoveEntryL(aId, aTarget, aDescendents));+
−
	return err;+
−
	}+
−
	+
−
+
−
+
−
/**+
−
 * DoMoveEntryL()+
−
 * Called from MoveEntry()+
−
 * */+
−
void CMsvIndexAdapter::DoMoveEntryL(TMsvId aId, TMsvId aTarget, CMsvEntrySelection* aDescendents /* DEFAULT=NULL */)+
−
    {+
−
    // Leave if the message store is not currently available.+
−
    User::LeaveIfError(iErrorState);+
−
    +
−
    CMsvCacheEntry* entry = NULL;   +
−
    CMsvCacheVisibleFolder* oldFolderNode = NULL;+
−
    TMsvId oldVisibleFolderId = KMsvNullIndexEntryIdValue;+
−
    +
−
    // 1. Find the entry in cache.+
−
    GetVisibleFolderDetailsL(aId, entry, oldFolderNode);+
−
        +
−
    // 2. Validate entry.+
−
    TBool des;+
−
    __ASSERT_DEBUG(entry->IsEntryAndStoreLocked(), PanicServer(EMsvMovingUnlockedEntry));+
−
    __ASSERT_DEBUG(entry->Entry().Parent() != aTarget, PanicServer(EMsvMovingWithinSameEntry));+
−
    IsADescendent(entry->Entry().Id(), aTarget, des);+
−
    if (des)+
−
        {// we need to put changes in another method.+
−
        User::Leave(KErrArgument);+
−
        }+
−
    +
−
     // 3. Fetch the parent entries.    +
−
    CMsvCacheEntry* oldParentEntry = NULL;+
−
    CMsvCacheEntry* newParentEntry = NULL;+
−
    TMsvId oldParentId = entry->Entry().Parent();+
−
    FindEntryL(oldParentId, oldParentEntry);+
−
    FindEntryL(aTarget, newParentEntry);+
−
    +
−
    // 4. Check if the owner flag of the old parent needs to be reset.    +
−
    TBool resetOldParentOwnerFlag = EFalse;+
−
    CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;+
−
    CleanupStack::PushL(children);+
−
    GetChildrenIdL(oldParentId, *children);+
−
    if(1 == children->Count() && oldParentEntry->Entry().Owner())+
−
        {+
−
        // Just set this flag, this is updated in step 14.+
−
        resetOldParentOwnerFlag = ETrue;+
−
        }+
−
    CleanupStack::PopAndDestroy(); //children+
−
    +
−
    // 5. If required, pre-allocate memory for child array of newParentEntry.+
−
    // This is later updated in step 12.+
−
    RArray<TMsvId>* newParentChildArr = newParentEntry->ChildIdArray();+
−
    if(newParentChildArr)+
−
        {+
−
        // This to ensure that future append does not fail.+
−
        newParentChildArr->ReserveL(newParentChildArr->Count() + 1);+
−
        }+
−
+
−
    // Step 6 & 7 is performed in this function.+
−
    TBool isChildEntriesNeedsUpdation = EFalse;+
−
    CMsvCacheVisibleFolder* newVisibleFolderNode = UpdateCacheForMoveEntryL(aTarget,                                                      +
−
                                                                            entry, +
−
                                                                            oldFolderNode, +
−
                                                                            aDescendents,+
−
                                                                            isChildEntriesNeedsUpdation);+
−
+
−
    TMsvId newVisibleFolderId = newVisibleFolderNode? newVisibleFolderNode->GetFolderId(): oldFolderNode->GetFolderId();+
−
+
−
    // 8. Update the entry.    +
−
    UpdateDates(*entry, EFalse);+
−
    entry->Entry().SetParent(aTarget);+
−
+
−
    // 9. Update the DB.+
−
    TRAPD(err, +
−
            iDbAdapter->BeginTransactionL();+
−
            // Update the actual entry+
−
            iDbAdapter->UpdateEntryL(entry->Entry(), newVisibleFolderId);+
−
            // Reset old parent owner flag.+
−
            if(resetOldParentOwnerFlag)+
−
                iDbAdapter->UpdateOwnerStatusL(oldParentId, oldParentEntry->Entry(), EFalse);+
−
            // Set new parent owner flag.+
−
            if(!newParentEntry->Entry().Owner())+
−
                iDbAdapter->UpdateOwnerStatusL(aTarget, newParentEntry->Entry(), ETrue);+
−
            // Update the child entries visibleFolderId in DB.+
−
            if(isChildEntriesNeedsUpdation)+
−
                iDbAdapter->UpdateVisibleFolderL(aDescendents, newVisibleFolderId);+
−
            iDbAdapter->CommitTransactionL();+
−
         );+
−
+
−
    if(err)+
−
        {        +
−
        TRAP_IGNORE(iDbAdapter->RollbackTransactionL());+
−
        // Undo step 8.+
−
        entry->Entry().SetParent(oldParentId);+
−
        // Undo step 7.+
−
        if(newVisibleFolderNode)    +
−
            newVisibleFolderNode->DeleteEntryL(aId);+
−
        if(isChildEntriesNeedsUpdation)+
−
            {+
−
            for(TInt index=(aDescendents->Count()-2); index>=0; index--)+
−
                {+
−
                newVisibleFolderNode->DeleteEntryL(aDescendents->At(index));+
−
                }+
−
            }+
−
        User::Leave(err);+
−
        }+
−
+
−
    // Nothing should fail after this. Ensure that +
−
    // all leaving function after this does not leave.+
−
    +
−
    // 10. Continuing step 7.1.+
−
    // Removing entry from old visible folder.+
−
    if(oldVisibleFolderId != newVisibleFolderId)+
−
        {+
−
        oldFolderNode->DeleteEntryL(aId);+
−
        }+
−
    +
−
    // 11. Continuing step 7.2.+
−
    // Removing child entries from old visible folder.+
−
    if(isChildEntriesNeedsUpdation)+
−
        {+
−
        for(TInt index=(aDescendents->Count()-2); index>=0; index--)+
−
            {+
−
            oldFolderNode->DeleteEntryL(aDescendents->At(index));+
−
            }+
−
        }+
−
+
−
    // 12. Add child id to new parent child array.+
−
    if(newParentChildArr)+
−
        {+
−
        // This will not leave, as memory is already reserved.+
−
        newParentChildArr->AppendL(aId);+
−
        }+
−
    +
−
    // 13. Remove child from old parent's child array.+
−
    RArray<TMsvId>* oldParentChildArr = oldParentEntry->ChildIdArray();+
−
    if(oldParentChildArr)+
−
        {+
−
        TInt pos = oldParentChildArr->Find(aId);+
−
        if(pos != KErrNotFound)+
−
            {+
−
            oldParentChildArr->Remove(pos);+
−
            }+
−
        }+
−
+
−
    // 14. Update owner flag of parent entries.+
−
    if(resetOldParentOwnerFlag)+
−
        {+
−
        oldParentEntry->Entry().SetOwner(EFalse);+
−
        }+
−
    newParentEntry->Entry().SetOwner(ETrue);+
−
    }+
−
+
−
+
−
+
−
+
−
void CMsvIndexAdapter::GetVisibleFolderDetailsL(TMsvId aEntryId, CMsvCacheEntry*& aEntry, CMsvCacheVisibleFolder*& aVisibleFolder)+
−
    {+
−
    TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
    dqIter.SetToFirst();+
−
    while((aVisibleFolder = dqIter++)!=NULL)+
−
        {+
−
        if(aVisibleFolder->GetEntry(aEntryId, aEntry))+
−
            {+
−
            break;+
−
            }+
−
        }+
−
    if(aEntry==NULL)+
−
        {+
−
        User::Leave(KErrNotFound);+
−
        }+
−
    }+
−
+
−
+
−
+
−
+
−
CMsvCacheVisibleFolder* CMsvIndexAdapter::UpdateCacheForMoveEntryL(TMsvId aNewParentId,+
−
                                                                   CMsvCacheEntry*& aOrigEntry, +
−
                                                                   CMsvCacheVisibleFolder* aOldVisibleFolderNode, +
−
                                                                   CMsvEntrySelection* aDescendents,+
−
                                                                   TBool& aIsChildEntriesNeedsUpdation)+
−
    {+
−
    // 6. Find the visible folder of new parent.+
−
    TMsvId newVisibleFolderId = aOldVisibleFolderNode->GetFolderId();+
−
    if(!GetVisibleFolderId(aNewParentId, newVisibleFolderId))+
−
        {+
−
        User::Leave(KErrNotFound);+
−
        }+
−
    +
−
    // 7. Check if the visible folders are different.+
−
    CMsvCacheVisibleFolder* newVisibleFolderNode = NULL;+
−
    if(aOldVisibleFolderNode->GetFolderId() != newVisibleFolderId)+
−
        {+
−
        // 7.1. If the visible folders are different, add duplicate+
−
        // entry under new visible folder. Removing entry from old+
−
        // visible folder is done in step 10 of DoMoveEntryL().+
−
        CMsvCacheEntry* newCacheEntry = iFreePoolInstance->EntryL();    +
−
        TRAPD(err, newCacheEntry->DupNDestroyL(aOrigEntry);+
−
                   newVisibleFolderNode = AddEntryToCacheL(newVisibleFolderId, newCacheEntry);+
−
             );+
−
        if(err)+
−
            {+
−
            iFreePoolInstance->ReleaseEntryWithoutTransaction(newCacheEntry);+
−
            User::Leave(err);+
−
            }+
−
    +
−
        // 7.2. Check if child entries also needs to be moved. +
−
        aOrigEntry = newCacheEntry;+
−
        if(aDescendents && !aOrigEntry->Entry().VisibleFolderFlag())+
−
             {+
−
             aIsChildEntriesNeedsUpdation = ETrue;+
−
             +
−
             // Add duplicate child entry under new visible folder.+
−
             // Removing child entries from old visible folder is done in step 11.+
−
             CMsvCacheEntry* childEntry = NULL;+
−
             CMsvCacheEntry* dupChildEntry = NULL;+
−
             for(TInt index=(aDescendents->Count()-2); index>=0; index--)+
−
                 {+
−
                 if(aOldVisibleFolderNode->GetEntry(aDescendents->At(index), childEntry))+
−
                     {+
−
                     dupChildEntry = NULL;+
−
                     // Create the duplicate of original entry.+
−
                     TRAP(err, dupChildEntry = iFreePoolInstance->EntryL();+
−
                               dupChildEntry->DupNDestroyL(childEntry);+
−
                               // Add under new visible folder node.+
−
                               newVisibleFolderNode->AddEntryL(dupChildEntry);+
−
                          );+
−
                     if(err)+
−
                         {+
−
                         // Delete should not be leaving...+
−
                         newVisibleFolderNode->DeleteEntryL(aOrigEntry->GetId());    // Undo step 7.1+
−
                         iFreePoolInstance->ReleaseEntryWithoutTransaction(dupChildEntry);   // Undo current entry+
−
                         // Undo remaining entries.+
−
                         for(TInt numEntries=index+1; numEntries<=(aDescendents->Count()-2); numEntries++)+
−
                             {+
−
                             newVisibleFolderNode->DeleteEntryL(aDescendents->At(numEntries));+
−
                             }+
−
                         User::Leave(err);+
−
                         }+
−
                     }   // if(oldFolderNode->GetEntry(aDescendents->At(index), childEntry))+
−
                 }   // for()+
−
             }   // if(aDescendents && !entry->Entry().VisibleFolderFlag())+
−
        }+
−
    return newVisibleFolderNode;+
−
    }+
−
+
−
+
−
+
−
+
−
/**+
−
 * IsADescendent()+
−
 */+
−
TInt CMsvIndexAdapter::IsADescendent(TMsvId aAscendentId, TMsvId aDescendentId, TBool& aDescendent)+
−
	{+
−
	__ASSERT_DEBUG((KMsvRootIndexEntryId != aAscendentId) && (KMsvRootIndexEntryId != aDescendentId), PanicServer(EMsvDescendentArgumentsRoot));+
−
	__ASSERT_DEBUG(aAscendentId!=aDescendentId, PanicServer(EMsvDescendentArgumentsEqual));+
−
	+
−
	aDescendent=EFalse;+
−
	while (KMsvRootIndexEntryId != aDescendentId)+
−
		{+
−
		CMsvCacheEntry* entry;	+
−
		TRAPD(err, FindEntryL(aDescendentId, entry));+
−
		if (err)+
−
			{+
−
			return KErrNotFound;+
−
			}+
−
		if (aDescendentId==aAscendentId)+
−
			{+
−
			aDescendent=ETrue;+
−
			break;+
−
			}+
−
		aDescendentId=entry->Entry().Parent();+
−
		}+
−
		+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * EntryExists()+
−
 */+
−
TBool CMsvIndexAdapter::EntryExists(TMsvId aId)+
−
	{+
−
	// First search the entry in cache, +
−
	// if cache is not empty...+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
	if(KMsvRootIndexEntryId == aId)+
−
		{+
−
		return true;+
−
		}+
−
#endif+
−
	if(!iFolderListHeader.IsEmpty())+
−
		{+
−
		CMsvCacheVisibleFolder* folderNode = NULL;+
−
		TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
		dqIter.SetToFirst(); +
−
		+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			if(aId == folderNode->GetFolderId())+
−
				{+
−
				return ETrue;+
−
				}+
−
			if(folderNode->EntryExists(aId))+
−
				{+
−
				return ETrue;+
−
				}+
−
			}+
−
		}+
−
	+
−
	TBool entryExists = EFalse;+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(entryExists = iDbAdapter->EntryExistsL(aId));+
−
		}+
−
	else+
−
		{+
−
		return EFalse;+
−
		}+
−
	if(!entryExists)+
−
		{+
−
		return EFalse;	+
−
		}+
−
	return ETrue;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * ChangeTemporaryData()+
−
 */+
−
TInt CMsvIndexAdapter::ChangeTemporaryData(const TMsvEntry& aNewEntryContents)+
−
	{+
−
	//__DEBUG_INVARIANT_ONEXIT;+
−
	+
−
	CMsvCacheEntry* entry;	+
−
+
−
	// find the entry in the index+
−
	TRAPD(err, FindEntryL(aNewEntryContents.Id(), entry));+
−
	if (err)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
+
−
	// Can only change a locked entry and not one marked as read only+
−
	if (!entry->IsEntryLocked() || entry->Entry().StandardFolder())+
−
		{+
−
		return KErrAccessDenied;+
−
		}+
−
+
−
	// Check if just changing temporary flags (ie those not stored on file)+
−
	entry->Entry().iData=aNewEntryContents.iData;+
−
+
−
	return KErrNone;	+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * ChangeAttributes()+
−
 */+
−
TInt CMsvIndexAdapter::ChangeAttributes(CMsvEntrySelection& aSelection, TUint aSetAttributes, TUint aClearAttributes)+
−
	{+
−
	TRAPD(leave, DoChangeAttributesL(aSelection, aSetAttributes, aClearAttributes));+
−
	return leave;+
−
	}+
−
	+
−
+
−
+
−
void CMsvIndexAdapter::DoChangeAttributesL(CMsvEntrySelection& aSelection, TUint aSetAttributes, TUint aClearAttributes)+
−
	{+
−
	// Leave if the message store is not currently available+
−
	User::LeaveIfError(iErrorState);+
−
+
−
	CArrayFixSeg<TInt32>* newData = new(ELeave)CArrayFixSeg<TInt32>(KMsvChangeAttributesListGranularity);+
−
	CleanupStack::PushL(newData);+
−
	CArrayFixSeg<TInt32>* newPcSyncCount = new(ELeave)CArrayFixSeg<TInt32>(KMsvChangeAttributesListGranularity);+
−
	CleanupStack::PushL(newPcSyncCount);+
−
+
−
	newData->ResizeL(aSelection.Count(), 0);+
−
	newPcSyncCount->ResizeL(aSelection.Count(), 0);+
−
+
−
	TInt count=aSelection.Count();+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	CMsvCacheEntry* entry = NULL;	+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TMsvId newVisibleFolderId = NULL;+
−
	if(iDbAdapter)+
−
		{+
−
		iDbAdapter->BeginTransactionL();+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
	while(count--)+
−
		{+
−
		// find the entry in the index+
−
		dqIter.SetToFirst();+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			if(folderNode->GetEntry(aSelection.At(count), entry))+
−
				{+
−
				newVisibleFolderId = folderNode->GetFolderId();+
−
				break;+
−
				}+
−
			}+
−
		if (entry == NULL)+
−
			{+
−
			User::Leave(KErrNotFound);+
−
			}+
−
		// can only change a locked entry and not one marked as read only+
−
		if (!entry->IsEntryLocked() || entry->Entry().StandardFolder())+
−
			{+
−
			User::Leave(KErrAccessDenied);+
−
			}+
−
			+
−
		// work out the new attributes+
−
		TBool persistedFlagsChanged;+
−
		if (!NewAttributes(entry->Entry(), newData->At(count), newPcSyncCount->At(count), aSetAttributes, aClearAttributes, persistedFlagsChanged))+
−
			{+
−
			// attributes don't need changing+
−
			aSelection.Delete(count);+
−
			newData->Delete(count);+
−
			newPcSyncCount->Delete(count);+
−
			continue;+
−
			}+
−
		if(persistedFlagsChanged)+
−
			{+
−
			TMsvEntry tEntry = entry->Entry();+
−
			tEntry.iData = newData->At(count);+
−
			tEntry.iPcSyncCount = newPcSyncCount->At(count);+
−
			TInt err = KErrNone;+
−
			if(iDbAdapter)+
−
				{+
−
				TRAP(err, iDbAdapter->UpdateEntryL(tEntry, newVisibleFolderId, EFalse));+
−
				}+
−
			else+
−
				{+
−
				User::Leave(ErrorState());	+
−
				}+
−
			if(err)+
−
				{+
−
				iDbAdapter->RollbackTransactionL();+
−
				User::Leave(err);+
−
				}+
−
			}+
−
		}+
−
	if(iDbAdapter)+
−
		{+
−
		iDbAdapter->CommitTransactionL();+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}	+
−
	+
−
	count=aSelection.Count();+
−
	while(count--)+
−
		{+
−
		// find the entry in the index+
−
		CMsvCacheEntry* entryPtr = NULL;+
−
		dqIter.SetToFirst();+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			if(folderNode->GetEntry(aSelection.At(count), entryPtr))+
−
				{+
−
				break;+
−
				}+
−
			}+
−
#if defined(_DEBUG)+
−
		TBool found = (NULL != entryPtr);+
−
		__ASSERT_DEBUG(found, PanicServer(EMsvChangeAttEmtryNotFound));+
−
#endif+
−
		entryPtr->Entry().iData=newData->At(count);+
−
		entryPtr->Entry().iPcSyncCount=newPcSyncCount->At(count);+
−
		}+
−
	CleanupStack::PopAndDestroy(2, newData);+
−
	if (!iIdle->IsActive())+
−
		{+
−
		iIdle->Start(TCallBack(BackGroundOperations, this));	+
−
		}+
−
		+
−
	}+
−
+
−
/**+
−
 * NewAttributes+
−
*/	+
−
TBool CMsvIndexAdapter::NewAttributes(const TMsvEntry& aEntry, TInt32& aNewData, TInt32& aNewPcSyncCount, TUint aSetAttributes, TUint aClearAttributes, TBool& aPersistedFlagsChanged)+
−
	{+
−
	aNewData = aEntry.iData;+
−
	aNewPcSyncCount = aEntry.iPcSyncCount;+
−
+
−
	// KMsvPcSyncCountAttribute is a dummy flag that is used to increment/decrement the PC Sync Count+
−
	// The visibility attribute is actually recorded as an 'invisible' flag in the index+
−
	if (aSetAttributes)+
−
		{+
−
		if (aSetAttributes & KMsvPcSyncCountAttribute)+
−
			{+
−
			aNewPcSyncCount++;+
−
			aSetAttributes &= ~KMsvPcSyncCountAttribute;+
−
			}+
−
		+
−
		const TInt32 mask = KMsvSendStateMax << KMsvSendingStateShift;+
−
		if (aSetAttributes & mask)+
−
			{+
−
			aNewData &= ~mask;+
−
			}+
−
			+
−
+
−
		aNewData |= aSetAttributes;+
−
+
−
		if (aSetAttributes & KMsvVisibilityAttribute)+
−
			{+
−
			aNewData &= ~TMsvEntry::KMsvEntryInvisibleFlag;+
−
			}+
−
		if (aSetAttributes & KMsvPendingDeleteAttribute)+
−
			{+
−
			aNewData |= TMsvEntry::KMsvEntryPendingDeleteFlag;+
−
			}+
−
		}+
−
+
−
	if (aClearAttributes)+
−
		{+
−
		if (aClearAttributes & KMsvPcSyncCountAttribute)+
−
			{+
−
			aNewPcSyncCount--;+
−
			aClearAttributes &= ~KMsvPcSyncCountAttribute;+
−
			}+
−
+
−
		aNewData &= ~aClearAttributes;+
−
+
−
		if (aClearAttributes&KMsvVisibilityAttribute)+
−
			{+
−
			aNewData |= TMsvEntry::KMsvEntryInvisibleFlag;+
−
			}+
−
			+
−
		if (aClearAttributes&KMsvPendingDeleteAttribute)+
−
			{+
−
			aNewData &= ~TMsvEntry::KMsvEntryPendingDeleteFlag;+
−
			}+
−
			+
−
		}+
−
+
−
	aPersistedFlagsChanged = (aNewData&TMsvEntry::KMsvEntryPersistedFlags)!=(aEntry.iData&TMsvEntry::KMsvEntryPersistedFlags) ||+
−
								aNewPcSyncCount != aEntry.iPcSyncCount;+
−
	return aNewData != aEntry.iData || aNewPcSyncCount != aEntry.iPcSyncCount;+
−
	}+
−
+
−
/**+
−
 * UpdateDates+
−
*/+
−
void CMsvIndexAdapter::UpdateDates(CMsvCacheEntry& aEntry, TBool aSetCreatedDate)+
−
	{+
−
	TTime now;+
−
	now.UniversalTime();+
−
	TMsvTime time;+
−
	time.SetTime(now);+
−
	aEntry.SetLastChangeDate(time);+
−
	+
−
	if (aSetCreatedDate)+
−
		{+
−
		aEntry.SetCreatedDate(time);+
−
		}+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * GetInternalEntry()+
−
 */+
−
TInt CMsvIndexAdapter::GetInternalEntry(TMsvId aId, CMsvCacheEntry*& aEntry)+
−
	{+
−
	CMsvCacheEntry* entry=NULL;+
−
	TRAPD(err, FindEntryL(aId, entry));+
−
	if(err!=KErrNone)+
−
		{+
−
		return err;+
−
		}+
−
	if(entry==NULL)+
−
		{+
−
		return KErrNotFound;+
−
		}+
−
	aEntry=entry;+
−
	return KErrNone;+
−
	}+
−
+
−
	+
−
/**+
−
 * Progress()+
−
*/ +
−
TMsvIndexProgress& CMsvIndexAdapter::Progress()+
−
	{+
−
	return iProgress;+
−
	}+
−
	+
−
+
−
/**+
−
 * EntryTreeInfo()+
−
 */+
−
TInt CMsvIndexAdapter::EntryTreeInfo(TMsvId aId, TMsvServerEntryInfo& aEntryInfo)+
−
	{+
−
	aEntryInfo.Reset();+
−
	aEntryInfo.iId = aId;+
−
+
−
	if( aId != KMsvRootIndexEntryId )+
−
		{+
−
		// Search up the tree to find which service the specified entry is under.+
−
		// Also, record the highest owning folder for the entry.+
−
		TMsvId id = aId;+
−
		CMsvCacheEntry* entry =NULL;+
−
		TRAPD(err, FindEntryL(id, entry));+
−
		if(err)+
−
			return KErrNotFound;+
−
		+
−
		id = entry->Entry().iId; //Id may be masked in cache+
−
		aEntryInfo.iId = id;+
−
		+
−
		// Get info for the entry.+
−
		aEntryInfo.iEntryOwnerId	= entry->EntryOwnerId();+
−
		aEntryInfo.iMtm				= entry->Entry().iMtm;+
−
		aEntryInfo.iType			= entry->Entry().iType;+
−
		+
−
		if( aEntryInfo.iType == KUidMsvFolderEntry )+
−
			{+
−
			// This is a folder - record as this may be needed.+
−
			aEntryInfo.iTopFolder = id;+
−
			}+
−
		+
−
		TBool found = (aEntryInfo.iType == KUidMsvServiceEntry);+
−
		while( !found )+
−
			{+
−
			// Move up the tree and get the next entry...+
−
			id = entry->Entry().Parent();+
−
			TRAPD(err, FindEntryL(id, entry));+
−
			if(err)+
−
			 return KErrNotFound;+
−
			+
−
			TUid type = entry->Entry().iType;+
−
			if( type == KUidMsvServiceEntry )+
−
				{+
−
				// Ok, we've found the owning service - stop looking.+
−
				found = ETrue;+
−
				}+
−
			else if( type == KUidMsvFolderEntry )+
−
				{+
−
				// This is a folder - record as this may be needed.+
−
				aEntryInfo.iTopFolder = id;+
−
				}+
−
			else +
−
				{+
−
				// This is a message or attachment entry - this implies that the+
−
				// original entry was part of an existing message. Set the owner+
−
				// ID to the highest parent.+
−
				aEntryInfo.iPartOfMessage	= ETrue;+
−
				aEntryInfo.iParentOwnerId	= entry->EntryOwnerId();+
−
				}+
−
			}+
−
		// Record the service and MTM...+
−
		aEntryInfo.iService = id;+
−
+
−
		aEntryInfo.iServiceMtm = entry->Entry().iMtm;+
−
		}+
−
	else+
−
		{+
−
		// This is the root entry! Mark the service as being the local service.+
−
		aEntryInfo.iType		= KUidMsvRootEntry;+
−
		aEntryInfo.iMtm			= KUidMsvLocalServiceMtm;+
−
		aEntryInfo.iService		= KMsvLocalServiceIndexEntryId;+
−
		aEntryInfo.iServiceMtm	= KUidMsvLocalServiceMtm;+
−
		aEntryInfo.iTopFolder	= KMsvRootIndexEntryId;+
−
		}+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
+
−
/**+
−
 * CommitNonCommitedEntries()+
−
 */+
−
void CMsvIndexAdapter::CommitNonCommitedEntries()+
−
	{+
−
	// 1. Commit transaction in DB.+
−
	if(iDbAdapter)+
−
		{+
−
		TRAPD(err, iDbAdapter->CommitTransactionL());+
−
		if(err)+
−
		    {+
−
		    RollbackAdditions();+
−
		    RollbackChanges();+
−
		    return;+
−
		    }+
−
		}+
−
+
−
	// 2. Update changed entries completely.+
−
	TInt count = iNonCommittedChangedEntryList.Count();+
−
	while(count)+
−
		{+
−
		TNonCommittedChangedEntries changedEntry = iNonCommittedChangedEntryList[--count];+
−
		CMsvCacheVisibleFolder* oldVisibleFolderNode = changedEntry.iOldVisibleFolderNode;+
−
        // Removing entry from old visible folder.+
−
        if(changedEntry.iNewVisibleFolderNode &&+
−
           oldVisibleFolderNode->GetFolderId() != changedEntry.iNewVisibleFolderNode->GetFolderId())+
−
            {+
−
            // Will never leave.+
−
            TRAP_IGNORE(changedEntry.iOldVisibleFolderNode->DeleteEntryL(changedEntry.iEntry->GetId()));+
−
            }+
−
        +
−
        // Removing child entries from old visible folder.+
−
        if(changedEntry.iDescendentList)+
−
            {+
−
            for(TInt index=(changedEntry.iDescendentList->Count()-2); index>=0; index--)+
−
                {+
−
                // Can leave with KErrNotFound.+
−
                TRAP_IGNORE(oldVisibleFolderNode->DeleteEntryL(changedEntry.iDescendentList->At(index)));+
−
                }+
−
            delete changedEntry.iDescendentList;            +
−
            }+
−
    +
−
        // Add child id to new parent child array.+
−
        if(changedEntry.iNewParentEntry && (changedEntry.iNewParentEntry->ChildIdArray()))+
−
            {+
−
            // This will not leave, as memory is already reserved.+
−
            TRAP_IGNORE(changedEntry.iNewParentEntry->ChildIdArray()->AppendL(changedEntry.iEntry->GetId()));+
−
            }+
−
        +
−
        // Remove child from old parent's child array.+
−
        if(changedEntry.iOldParentEntry)+
−
            {+
−
            RArray<TMsvId>* oldParentChildArr = changedEntry.iOldParentEntry->ChildIdArray();+
−
            if(oldParentChildArr)+
−
                {+
−
                TInt pos = oldParentChildArr->Find(changedEntry.iEntry->GetId());+
−
                if(pos != KErrNotFound)+
−
                    {+
−
                    oldParentChildArr->Remove(pos);+
−
                    }+
−
                }+
−
            }+
−
    +
−
        // Update owner flag of parent entries.+
−
        if(changedEntry.iResetOldParentOwnerFlag)+
−
            {+
−
            changedEntry.iOldParentEntry->Entry().SetOwner(EFalse);+
−
            }+
−
        if(changedEntry.iNewParentEntry)+
−
            {+
−
            changedEntry.iNewParentEntry->Entry().SetOwner(ETrue);+
−
            }+
−
		}+
−
+
−
	// 3. Reset non-committed entry list.+
−
	iNonCommittedAddedEntryList.ResetAndDestroy();+
−
	iNonCommittedChangedEntryList.Reset();+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * RollbackAdditions()+
−
 */+
−
void CMsvIndexAdapter::RollbackAdditions()+
−
	{+
−
	// 1. Rollback transaction in DB.+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->RollbackTransactionL());+
−
		}+
−
	+
−
	// 2. Delete added entry from cache.+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TInt count = iNonCommittedAddedEntryList.Count();+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	while(count)+
−
		{+
−
		--count;+
−
		dqIter.SetToFirst();+
−
	    while ((folderNode = dqIter++) != NULL)+
−
	        {+
−
	        if(iNonCommittedAddedEntryList[count]->iVisibleFolder == folderNode->GetFolderId())+
−
	           	{+
−
	           	iNonCommittedAddedEntryList[count]->entry->LockEntry();+
−
	        	// Error can cause if the entry does not exist. Ignore.+
−
	        	TRAP_IGNORE(folderNode->DeleteEntryL(iNonCommittedAddedEntryList[count]->entry->GetId()));+
−
	        	break;+
−
	        	}+
−
	        };+
−
		}+
−
	+
−
	// 3. Reset non-committed entry list.+
−
	iNonCommittedAddedEntryList.ResetAndDestroy();+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * RollbackChanges()+
−
 */+
−
void CMsvIndexAdapter::RollbackChanges()+
−
	{+
−
	// 1. Rollback transaction in DB.+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->RollbackTransactionL());+
−
		}+
−
	+
−
	// 2. Undo changed entry in cache.+
−
	TInt count = iNonCommittedChangedEntryList.Count();+
−
	while(count)+
−
		{+
−
		TNonCommittedChangedEntries changedEntry = iNonCommittedChangedEntryList[--count];+
−
		CMsvCacheEntry* oldEntry = changedEntry.iEntry;+
−
+
−
		// If the visible folder Id of the entry is changed, +
−
		// oldEntry represents the entry under new visible folder node.+
−
		// Get the actual old entry from old visible folder node.+
−
		if(changedEntry.iNewVisibleFolderNode)+
−
		    {+
−
		    // This will be non leaving as entry is already present.+
−
		    if(changedEntry.iOldVisibleFolderNode->GetEntry(oldEntry->GetId(), oldEntry))+
−
				{+
−
				// Remove added entry from new visible node. +
−
				// This function will never leave in the current +
−
				// scenario, hence ignoring the error.+
−
				TRAP_IGNORE(changedEntry.iNewVisibleFolderNode->DeleteEntryL(oldEntry->GetId()));+
−
				}+
−
		    }+
−
        oldEntry->SetEntryOwnerId(changedEntry.iBkpEntry->EntryOwnerId());+
−
        oldEntry->RollBackCopyEntry(changedEntry.iBkpEntry->Entry());+
−
        iFreePoolInstance->ReleaseEntryWithoutTransaction(changedEntry.iBkpEntry);+
−
        +
−
        if(changedEntry.iDescendentList)+
−
            {+
−
            delete changedEntry.iDescendentList;+
−
            }+
−
 		}+
−
        +
−
	// 3. Reset non-committed entry list.+
−
	iNonCommittedChangedEntryList.Reset();+
−
	}+
−
+
−
+
−
+
−
+
−
CMsvIndexAdapter::TMsvServerEntryInfo::TMsvServerEntryInfo()+
−
	{+
−
	iId				= KMsvNullIndexEntryIdValue;+
−
	iTopFolder		= KMsvNullIndexEntryIdValue;+
−
	iService		= KMsvNullIndexEntryIdValue;+
−
	iMtm			= KUidMsvNullEntry;+
−
	iType			= KUidMsvNullEntry;+
−
	iServiceMtm		= KUidMsvNullEntry;+
−
	iEntryOwnerId	= KMsvServerId.iId; +
−
	iParentOwnerId	= KMsvServerId.iId;+
−
	iPartOfMessage	= EFalse;	+
−
	}+
−
+
−
+
−
+
−
+
−
void CMsvIndexAdapter::TMsvServerEntryInfo::Reset()+
−
	{+
−
	iId				= KMsvNullIndexEntryIdValue;+
−
	iTopFolder		= KMsvNullIndexEntryIdValue;+
−
	iService		= KMsvNullIndexEntryIdValue;+
−
	iMtm			= KUidMsvNullEntry;+
−
	iType			= KUidMsvNullEntry;+
−
	iServiceMtm		= KUidMsvNullEntry;+
−
	iEntryOwnerId	= KMsvServerId.iId; +
−
	iParentOwnerId	= KMsvServerId.iId;+
−
	iPartOfMessage	= EFalse;	+
−
	}	+
−
+
−
+
−
/**+
−
Need to see the posibilty of getting this first from cache+
−
*/+
−
TBool CMsvIndexAdapter::GetNextSiblingL(TMsvId aId,TMsvId aParentId,TMsvId& aNextSiblingId)+
−
	{+
−
	TBool flag = EFalse;+
−
	if(iDbAdapter)+
−
		{+
−
		flag = iDbAdapter->GetNextSiblingL(aId, aParentId, aNextSiblingId);+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
	return flag;+
−
	}+
−
+
−
+
−
/**+
−
Need to see the posibilty of getting this first from cache+
−
*/+
−
TBool CMsvIndexAdapter::GetFirstChildIdL(TMsvId aParentId,TMsvId& aFirstChild)+
−
	{+
−
	TBool flag = EFalse;+
−
	if(iDbAdapter)+
−
		{+
−
		flag = iDbAdapter->GetFirstChildIdL(aParentId, aFirstChild);+
−
		}+
−
	else+
−
		{+
−
		User::Leave(ErrorState());	+
−
		}+
−
	return flag;+
−
	}+
−
+
−
+
−
/**+
−
 * SetLocalServiceComplete+
−
 * @param TUint: Drive Id of the local service folder node.+
−
 *+
−
 * Code changes for PREQ 557.+
−
 * Sets the localservice visiblefolder.+
−
 */	+
−
void CMsvIndexAdapter::SetLocalServiceComplete()+
−
	{+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	dqIter.SetToFirst();+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
+
−
	while((folderNode = dqIter++)!=NULL)+
−
		{+
−
		if(KMsvLocalServiceIndexEntryIdValue == folderNode->GetFolderId())+
−
			{+
−
			folderNode->SetComplete(ETrue);+
−
			break;+
−
			}+
−
		}+
−
	}+
−
+
−
	+
−
/**+
−
 *BackGroundOperations()+
−
 *@param  aPtr 	A TAny*+
−
 *@return TBool ETrue if the background operation needs to be rescheduled.+
−
 *				EFalse if the background operation need not be rescheduled.+
−
 */+
−
TBool CMsvIndexAdapter::BackGroundOperations(TAny* aPtr)+
−
	{+
−
	return ((CMsvIndexAdapter*)aPtr)->DoBackGroundOperations();+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 *DoBackGroundOperations()+
−
 *@param  None+
−
 *@return TBool ETrue if the background operation needs to be rescheduled.+
−
 *				EFalse if the background operation need not be rescheduled.+
−
 */+
−
TBool CMsvIndexAdapter::DoBackGroundOperations()+
−
	{+
−
	TInt stopBackgroundOperation = EFalse;+
−
	TRAPD(err, DoBackGroundOperationsL(stopBackgroundOperation));+
−
	if(KErrNone == err && !stopBackgroundOperation)+
−
		{+
−
		return ETrue;+
−
		}+
−
	return EFalse;	+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 *DoBackGroundOperations()+
−
 *This is the background operation state machine, this will perform a set+
−
 *of operations in each of the iteration.+
−
 *+
−
 *@param  None+
−
 *@return void+
−
 */+
−
void CMsvIndexAdapter::DoBackGroundOperationsL(TBool& aStopBackgroundOperation)+
−
	{+
−
	iFreePoolInstance->RoutineFreePoolCleanUpL();+
−
	switch(iBackgroundOperationState)+
−
		{+
−
		case ERemoveDeletedEntries:+
−
			{+
−
			iBackgroundOperationState = EAllocateMemoryOperation;+
−
			DoRemoveDeletedEntriesL();+
−
			break;+
−
			}+
−
		case EAllocateMemoryOperation:+
−
			{+
−
			iBackgroundOperationState = ECheckBlockSize;+
−
			if(CheckAndAllocateMemoryL())+
−
				{+
−
				iBackgroundOperationPerformed = 0;+
−
				break;	+
−
				}+
−
			iBackgroundOperationPerformed++;	+
−
			}+
−
		case ECheckBlockSize:+
−
			{+
−
			iBackgroundOperationState = ENoOperation;	+
−
			SplitBlockL();+
−
			break;+
−
			}+
−
		case ENoOperation:+
−
		default:+
−
			{+
−
			iBackgroundOperationState = ERemoveDeletedEntries;+
−
			// The background operation has run multiple times, without doing+
−
			// much work, so it can be stopped temporarily.+
−
			if(iBackgroundOperationPerformed >= 5)+
−
				{+
−
				iBackgroundOperationPerformed = 0;+
−
				aStopBackgroundOperation = ETrue;+
−
				}+
−
				+
−
			break;+
−
			}		+
−
		}+
−
+
−
	}+
−
+
−
+
−
+
−
/**+
−
 *CheckAndAllocateMemory+
−
 *Will check the state of the free pool and allocate memory if required.+
−
 *Allocation will be done if 70% of the CMsvCacheEntries created are used.+
−
 *+
−
 *@return  TBool    ETrue,  if allocation has been done.+
−
 *		   			EFalse, if no allocation is done.			+
−
 */+
−
TBool CMsvIndexAdapter::CheckAndAllocateMemoryL()+
−
	{+
−
	if(iFreePoolInstance->IsAllocationRequiredL())+
−
		{+
−
		iFreePoolInstance->AllocateMemoryL();+
−
		return ETrue;+
−
		}+
−
	return EFalse;	+
−
	}+
−
	+
−
+
−
+
−
	+
−
/**+
−
 *SplitBlockL+
−
 *Will sort and split the blocks of CMsvCacheEntries.+
−
 *+
−
 *@return  void     		+
−
 */	+
−
void CMsvIndexAdapter::SplitBlockL()+
−
	{+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	dqIter.SetToFirst();+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	while((folderNode = dqIter++)!=NULL)+
−
		{+
−
		folderNode->SplitBlockL();+
−
		}+
−
	}+
−
+
−
+
−
+
−
/**+
−
 *ForceDeleteEntry+
−
 *Deletes the TMsvEntry even if it is not in the cache.This does not require +
−
 *the entry to be locked.+
−
 *+
−
 *@param aId  TMsvId, id ofthe entry to be deleted.+
−
 *@return TInt Any of the system wide error codes.+
−
 */+
−
TInt CMsvIndexAdapter::ForceDeleteEntry(TMsvId aId)+
−
	{+
−
	TRAPD(leave, DoForceDeleteEntryL(aId));+
−
	return leave;+
−
	}+
−
+
−
+
−
+
−
/**+
−
 *DoForceDeleteEntryL+
−
 *Called from ForceDeleteEntry+
−
 *+
−
 *@param aId  TMsvId, id ofthe entry to be deleted.+
−
 *@return void +
−
 */+
−
void CMsvIndexAdapter::DoForceDeleteEntryL(TMsvId aId)+
−
	{+
−
	User::LeaveIfError(iErrorState);+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
	+
−
	if(!iDbAdapter)+
−
		{+
−
		User::Leave(ErrorState());+
−
		}+
−
	CMsvCacheEntry* entry = NULL;+
−
	TBool releaseEntry = FindEntryL(aId, entry, EFalse);+
−
	TMsvId parentId = entry->Entry().Parent();+
−
	TRAPD(err, iDbAdapter->DeleteEntryL(aId));+
−
	// If the entry does not exists in cache,+
−
	// we need to release the entry explicitly.+
−
	if(releaseEntry)+
−
		{+
−
		iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
		User::LeaveIfError(err);+
−
		}+
−
	else+
−
		{+
−
		User::LeaveIfError(err);+
−
		// Otherwise remove the entry from cache.+
−
		dqIter.SetToFirst();+
−
		while((folderNode = dqIter++)!=NULL)+
−
			{+
−
			TRAPD(err, folderNode->DeleteEntryL(aId, ETrue));	+
−
			if(KErrNone == err)+
−
				{+
−
			 	break;+
−
			 	}+
−
			}+
−
		}+
−
	//Find the parent entry in cache and check for any children.+
−
	//If there are no more children under the parent, then+
−
	//reset the owner flag in cache and database.+
−
	CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;+
−
	CleanupStack::PushL(children);+
−
	releaseEntry = FindEntryL(parentId, entry, EFalse);+
−
	TRAP(err, +
−
		GetChildrenIdL(parentId, *children);+
−
		if(0 == children->Count() && entry->Entry().Owner())+
−
			{+
−
			iDbAdapter->UpdateOwnerStatusL(parentId, entry->Entry(), EFalse);+
−
			entry->Entry().SetOwner(EFalse);+
−
			}+
−
		);+
−
	if(releaseEntry)+
−
		{+
−
		iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
		}+
−
	User::LeaveIfError(err);+
−
	CleanupStack::PopAndDestroy(); //children+
−
	}+
−
+
−
+
−
+
−
/**+
−
 *DeleteSelectionUsingTransaction+
−
 *Deletes a selection of TMsvEntries.This will also delete enteries that are not locked.+
−
 *+
−
 *@param aSelection  CMsvEntrySelection&, selection of the TMsvEntries.+
−
 @param TInt Any of the system wide error codes.+
−
 */+
−
+
−
TInt CMsvIndexAdapter::DeleteSelectionUsingTransaction(const CMsvEntrySelection& aSelection)+
−
	{+
−
	TRAPD(leave, DoDeleteSelectionUsingTransactionL(aSelection));+
−
	return leave;+
−
	}+
−
+
−
+
−
/**+
−
 *DoDeleteSelectionUsingTransactionL+
−
 *Called from DeleteSelectionUsingTransaction.+
−
 *+
−
 *@param aSelection  CMsvEntrySelection&, selection of the TMsvEntries.+
−
 @param void+
−
 */+
−
void CMsvIndexAdapter::DoDeleteSelectionUsingTransactionL(const CMsvEntrySelection& aSelection)+
−
	{+
−
    User::LeaveIfError(iErrorState);+
−
    if(!iDbAdapter)+
−
        {+
−
        User::Leave(iErrorState);+
−
        }+
−
    +
−
    CMsvCacheVisibleFolder* folderNode = NULL;+
−
    TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
    const TInt count = aSelection.Count();+
−
    +
−
    if(!count)+
−
        {+
−
        return;+
−
        }   +
−
        +
−
    CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;+
−
    CleanupStack::PushL(children);+
−
    CMsvCacheEntry* entry = NULL;+
−
    TBool releaseEntry = FindEntryL(aSelection.At(0), entry, EFalse);+
−
    TMsvId parentId = entry->Entry().Parent();+
−
    if(releaseEntry)+
−
        {+
−
        iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
        }+
−
+
−
    // Find the parent in the cache - we may need to update its owner status flag both in cache and DB.+
−
    TBool updateTheParent = ETrue;+
−
    TRAPD(err, releaseEntry = FindEntryL(parentId, entry, EFalse)); // can't let it leave - need to delete the child in any case.+
−
    if(err == KErrNotFound)+
−
        {+
−
        updateTheParent = EFalse;+
−
        if(releaseEntry)+
−
            {+
−
            iFreePoolInstance->ReleaseEntry(entry, ETrue);+
−
            }+
−
        }+
−
    else+
−
        {+
−
        // Get parent's children.+
−
        GetChildrenIdL(parentId, *children); // can leave - we'll let it leave as there's nothing to be rolled back now.+
−
        if(children->Count() > 1)+
−
            updateTheParent = EFalse;+
−
        }+
−
        +
−
    // Perform DB operations:+
−
    //      - Delete the entry.+
−
    //      - Update owner status flag of the parent.+
−
    iDbAdapter->DeleteEntryL(aSelection); // can leave - we'll let it leave as there's nothing to be rolled back now.+
−
    if(updateTheParent)+
−
        {+
−
        TRAP(err, iDbAdapter->UpdateOwnerStatusL(parentId, entry->Entry(), EFalse));+
−
        }+
−
    // Leave if DB operations fail. Cache is not touched.+
−
    if(err)+
−
        {+
−
        TRAP_IGNORE(iDbAdapter->RollbackTransactionL()); //+
−
        User::Leave(err);+
−
        }+
−
    else+
−
        {+
−
        if(updateTheParent)+
−
            {+
−
            entry->Entry().SetOwner(EFalse);+
−
            }+
−
        // Do the cache operations. These don't require any memory allocation and cannot fail.+
−
        for (TInt index=0; index<count; ++index)+
−
            {+
−
            // If the entry is a visible folder, then delete the node.+
−
            dqIter.SetToFirst(); +
−
            while((folderNode = dqIter++)!=NULL)+
−
                {+
−
                if(folderNode->GetFolderId() == aSelection.At(index))+
−
                    {+
−
                    folderNode->iDlink.Deque();+
−
                    delete folderNode;+
−
                    break;+
−
                    }+
−
                }+
−
            +
−
            // Delete the entry from under its parent visible folder.+
−
            dqIter.SetToFirst();+
−
            while((folderNode = dqIter++)!=NULL)+
−
                {+
−
                TRAPD(err, folderNode->DeleteEntryL(aSelection.At(index), ETrue));  +
−
                if(KErrNone == err) +
−
                    {+
−
                    break;+
−
                    }+
−
                }+
−
            }+
−
        }+
−
    +
−
    // Update SearchSort delta cache.+
−
    TMsgType aType(EDeletedMsg);+
−
    if(CMSvSearchSortCacheManager::Instance()->iManagerEntry != NULL)+
−
        {   +
−
        if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0)+
−
            {+
−
            for(TInt ii =0; ii < aSelection.Count() ; ii ++)+
−
                {+
−
                CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aSelection[ii],aType);+
−
                }+
−
            }+
−
        }+
−
+
−
    CleanupStack::PopAndDestroy(); //children+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * BeginTransaction()+
−
 * +
−
 * Starts a new DB transaction.+
−
 */+
−
void CMsvIndexAdapter::BeginTransaction()+
−
	{+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->BeginTransactionL());+
−
		}+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * CommitTransaction()+
−
 * +
−
 * Commits an already opened transaction.+
−
 */+
−
void CMsvIndexAdapter::CommitTransaction()+
−
	{+
−
	if(iDbAdapter)+
−
		{+
−
		TRAP_IGNORE(iDbAdapter->CommitTransactionL());+
−
		}+
−
	}+
−
	+
−
+
−
+
−
/**+
−
 * DoRemoveDeletedEntriesL()+
−
 * +
−
 * Deletes all the entries whose PcSyncCount is 0 and delete flag is set.+
−
 */+
−
TBool CMsvIndexAdapter::DoRemoveDeletedEntriesL()+
−
	{+
−
	CMsvCacheEntry* parent = NULL;+
−
	CMsvCacheEntry* entry = NULL;+
−
	CMsvCacheEntry* siblingEntry = NULL;+
−
	TMsvId siblingId = KMsvNullIndexEntryId;+
−
	TMsvId visibleFolder = KMsvNullIndexEntryId;+
−
	TMsvId firstchildId = KMsvNullIndexEntryId;+
−
	TInt commitCount = 1;+
−
	+
−
	// Find deleted folder+
−
	FindEntryL(KMsvDeletedEntryFolderEntryId, parent, ETrue);+
−
+
−
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;+
−
	CleanupStack::PushL(selection);+
−
+
−
	// All deleted entries are a child of deleted folder+
−
	if(iDbAdapter->GetFirstChildIdL(parent->Entry().Id(),firstchildId))+
−
		{+
−
		iDbAdapter->GetEntryL(firstchildId, entry, visibleFolder);+
−
		}+
−
					+
−
	while(entry && commitCount > 0)+
−
		{+
−
		if (entry->Entry().PcSyncCount() <= 0)+
−
			{+
−
			// Add entry to list of things to be deleted+
−
			__ASSERT_DEBUG(entry->Entry().Deleted(), PanicServer(EMsvDeletedFlagNotSet));+
−
			+
−
			User::LeaveIfError(LockEntryAndStore(entry->Entry().Id()));+
−
			selection->AppendL(entry->Entry().Id());+
−
			// Will the next entry be deleted?+
−
			if(iDbAdapter->GetNextSiblingL(entry->Entry().Id(), parent->Entry().Id(), siblingId))+
−
				{+
−
				iDbAdapter->GetEntryL(siblingId, siblingEntry, visibleFolder);+
−
				if(siblingEntry->Entry().PcSyncCount() > 0)+
−
					{+
−
					commitCount--;+
−
					}+
−
				}+
−
			else+
−
			    break;+
−
			}+
−
		iFreePoolInstance->ReleaseEntryWithoutTransaction(entry);+
−
		entry = siblingEntry;+
−
		}+
−
+
−
	if (selection->Count() > 0)+
−
		{+
−
		User::LeaveIfError(DeleteSelection(*selection));+
−
		}+
−
	CleanupStack::PopAndDestroy(); // selection+
−
	+
−
	// Possibly more to delete if we did not get to the end of the child list+
−
	TBool retVal = entry != NULL;+
−
	iFreePoolInstance->ReleaseEntryWithoutTransaction(entry);+
−
	return retVal;+
−
	}+
−
+
−
+
−
+
−
+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
/**+
−
 * GetChildrenAllL()+
−
 *+
−
 * Code added for PREQ 557.+
−
 *+
−
 * The function is similar to function GetChildrenL(), but+
−
 * additionally it fetches entries from all the drive in the+
−
 * preferred drive list.+
−
 */+
−
void CMsvIndexAdapter::GetChildrenAllL(TMsvId aId, CArrayPtr<const TMsvEntry>& aSelection, const TMsvSelectionOrdering& aOrdering, TUid aMtm, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	TMsvPreferredDrive driveEntry;+
−
	CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();+
−
	for(TInt index=0; index<driveList->Count(); ++index)+
−
		{+
−
		driveEntry = (*driveList)[index];+
−
		if(EMsvMessageStoreAvailableStatus == driveEntry.status)+
−
			{+
−
			GetChildrenL(MaskTMsvId(driveEntry.driveId, aId), aSelection, aOrdering, aMtm, aFilterByOwnerId, aOwnerId);+
−
			}+
−
		}+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * GetChildrenIdAll()+
−
 *+
−
 * Code added for PREQ 557.+
−
 *+
−
 * The function is similar to function GetChildrenId(), but+
−
 * additionally it fetches entries from all the drive in the+
−
 * preferred drive list.+
−
 */+
−
TInt CMsvIndexAdapter::GetChildrenIdAll(TMsvId aId, const CMsvEntryFilter& aFilter, CMsvEntrySelection& aSelection)+
−
	{+
−
	TSecureId dummy = KMsvServerId.iId;+
−
	return GetChildrenIdAll(aId, aFilter, aSelection, EFalse, dummy);+
−
	}+
−
	+
−
	 +
−
+
−
// Overloaded.+
−
TInt CMsvIndexAdapter::GetChildrenIdAll(TMsvId aId, const CMsvEntryFilter& aFilter, CMsvEntrySelection& aSelection, TBool aFilterByOwnerId, TSecureId aOwnerId)+
−
	{+
−
	TInt err = KErrNone;+
−
	TMsvPreferredDrive driveEntry;+
−
	CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();+
−
	for(TInt index=0; index<driveList->Count(); ++index)+
−
		{+
−
		driveEntry = (*driveList)[index];+
−
		if(EMsvMessageStoreAvailableStatus == driveEntry.status)+
−
			{+
−
			err = GetChildrenId(MaskTMsvId(driveEntry.driveId, aId), aFilter, aSelection, aFilterByOwnerId, aOwnerId);+
−
			if(KErrNone != err)+
−
				{+
−
				return err;+
−
				}+
−
			}+
−
		}+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
+
−
/**+
−
 * RemoveDriveL()+
−
 * +
−
 * This function is added in PREQ 557.+
−
 * @param TUint: The drive priority, which is also the index of drive +
−
 *               entry in message server data structure.+
−
 * @param TBool: If the drive still remains in the preferred drive list.+
−
 * @return None.+
−
 * +
−
 */+
−
void CMsvIndexAdapter::RemoveDriveL(TUint aDriveId, TUint aDriveIndex, TBool aIsStdFolderVisible /*=ETrue */)+
−
	{+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
+
−
	// Browse through the folder list.+
−
    dqIter.SetToFirst();+
−
    while ((folderNode = dqIter++) != NULL)+
−
        {+
−
        // If the folder is from the same drive.+
−
        // Caution: If the current drive is removed, +
−
        // this will also include root and localService.+
−
        if(folderNode->GetDrive() == aDriveId)+
−
        	{+
−
       				folderNode->iDlink.Deque();+
−
       				delete folderNode;+
−
        			}+
−
        }	// while ((folderNode = dqIter++) != NULL)+
−
    +
−
    // If current drive is removed, +
−
    // Remove localService entry as well.+
−
+
−
	// Detach the database and remove maxId entry.   	+
−
    if(!aIsStdFolderVisible)+
−
    	{+
−
    	iDbAdapter->DetachDBL(aDriveId);+
−
    	iMaxMsvIdList[aDriveId] = NULL;+
−
+
−
		CMsvPreferredDriveList::GetDriveList()->UpdateDriveIdL(aDriveIndex, KMsvInvalidDriveId);+
−
		CMsvPreferredDriveList::GetDriveList()->UpdateDriveStatusL(aDriveIndex, EMsvDriveDiskNotAvailableStatus);+
−
		}+
−
	}+
−
+
−
+
−
+
−
+
−
+
−
/**+
−
 * AddDriveL()+
−
 * +
−
 * This function is added in PREQ 557.+
−
 * @param TUint: The drive priority, which is also the index of drive +
−
 *               entry in message server data structure.+
−
 * +
−
 */+
−
void CMsvIndexAdapter::AddDriveL(TUint aDrivePriority)+
−
	{+
−
	// Assign a new drive id.+
−
	TUint driveId = GetNextAvailableDriveId();+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveIdL(aDrivePriority, driveId);+
−
	+
−
	// Attach the database.+
−
	TMsvId maxId;+
−
	TMsvPreferredDrive driveEntry;+
−
	CMsvPreferredDriveList::GetDriveList()->DriveInfoL(aDrivePriority, driveEntry);+
−
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)	+
−
	TRAPD(err, iDbAdapter->AttachDBL(driveEntry.driveNum, driveId, maxId, &iServer.MessageDBAdapter()));+
−
#else+
−
	TRAPD(err, iDbAdapter->AttachDBL(driveEntry.driveNum, driveId, maxId));+
−
#endif+
−
	WrapDBErrorL(err);+
−
	+
−
	// Insert the max Id in the list.+
−
	iMaxMsvIdList[driveId] = ((maxId >= MaskTMsvId(driveId, KFirstFreeEntryId))? (maxId+1) : MaskTMsvId(driveId, KFirstFreeEntryId));+
−
	}+
−
+
−
+
−
+
−
+
−
/**+
−
 * ChangeDriveL()+
−
 * +
−
 * This function is added in PREQ 557.+
−
 * @param TUint: The drive priority, which is also the index of drive +
−
 *               entry in message server data structure.+
−
 * @param TBool: If the previous drive still remains in the preferred drive list.+
−
 * @return None.+
−
 * +
−
 */+
−
void CMsvIndexAdapter::ChangeDriveL(TUint aNewDriveIndex, TBool aIsStdFolderVisible /*= ETrue*/)+
−
	{+
−
	// Rule1: Remove all non-standard folder node of current drive.+
−
	TInt oldCurrentDriveIndex = CMsvPreferredDriveList::GetDriveList()->CurrentDriveIndex();+
−
	RemoveDriveL(KCurrentDriveId, oldCurrentDriveIndex, EFalse);+
−
+
−
	// If old drive should be visible, re-attach the drive.+
−
	// This assigns a new drive id to the old current drive.+
−
	if(aIsStdFolderVisible)+
−
		{+
−
		CMsvPreferredDriveList::GetDriveList()->UpdateDriveStatusL(oldCurrentDriveIndex, EMsvMessageStoreAvailableStatus);+
−
		AddDriveL(oldCurrentDriveIndex);+
−
		}+
−
+
−
	+
−
	// Clear search sort cache db table+
−
	TRAPD(err, GetDbAdapter()->ClearDBContentsL());+
−
	WrapDBErrorL(err);+
−
	+
−
	+
−
	// 3. Flush up entries from new current drive, +
−
	// if it is already attached.+
−
	+
−
	TMsvPreferredDrive driveEntry;+
−
	CMsvPreferredDriveList::GetDriveList()->DriveInfoL(aNewDriveIndex, driveEntry);	+
−
	if(KMsvInvalidDriveId != driveEntry.driveId)+
−
		{+
−
		RemoveDriveL(driveEntry.driveId, aNewDriveIndex, EFalse);+
−
		}+
−
	+
−
+
−
	// Assign a new drive Id to the drive.+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveIdL(aNewDriveIndex, KCurrentDriveId);+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveStatusL(aNewDriveIndex, EMsvMessageStoreAvailableStatus);+
−
	+
−
+
−
	// Assign a new drive Id to the drive.+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveIdL(aNewDriveIndex, KCurrentDriveId);+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveStatusL(aNewDriveIndex, EMsvMessageStoreAvailableStatus);+
−
	// --------- Attach the database and update MaxId.		+
−
	TMsvId maxId;+
−
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)+
−
	TRAP(err, iDbAdapter->AttachDBL(driveEntry.driveNum, KCurrentDriveId, maxId, &iServer.MessageDBAdapter()));+
−
#else+
−
	TRAP(err, iDbAdapter->AttachDBL(driveEntry.driveNum, KCurrentDriveId, maxId));+
−
#endif+
−
	WrapDBErrorL(err);+
−
	+
−
	// Insert the max Id in the list.+
−
	iMaxMsvIdList[KCurrentDriveId] = ((maxId >= MaskTMsvId(KCurrentDriveId, KFirstFreeEntryId))? (maxId+1) : MaskTMsvId(KCurrentDriveId, KFirstFreeEntryId));		+
−
+
−
+
−
	// ------- Create a root node and its children.+
−
	TMsvId folderId = MaskTMsvId(KCurrentDriveId, KMsvRootIndexEntryId);+
−
	+
−
	// Add local service folder node in the folder list.+
−
	iRootNode = CMsvCacheVisibleFolder::NewL(folderId);+
−
	iFolderListHeader.AddFirst(*iRootNode);+
−
	+
−
	// Fetch children of root folder to cache.+
−
	RPointerArray<CMsvCacheEntry> childEntryList;+
−
	CleanupClosePushL(childEntryList);+
−
	+
−
	TRAP(err, iDbAdapter->GetChildrenL(folderId, childEntryList));+
−
	WrapDBErrorL(err);+
−
	iRootNode->AddEntryListL(childEntryList, ETrue);+
−
	childEntryList.Reset();	+
−
+
−
	+
−
	// ------- Create a local service node and its children.+
−
	folderId = MaskTMsvId(KCurrentDriveId, KMsvLocalServiceIndexEntryId);+
−
	+
−
	// Add local service folder node in the folder list.+
−
	CMsvCacheVisibleFolder* localServiceFolder = CMsvCacheVisibleFolder::NewL(folderId);+
−
	iFolderListHeader.AddFirst(*localServiceFolder);+
−
	+
−
	TRAP(err, iDbAdapter->GetChildrenL(folderId, childEntryList));+
−
	WrapDBErrorL(err);+
−
	localServiceFolder->AddEntryListL(childEntryList, ETrue);+
−
+
−
	CleanupStack::PopAndDestroy();   // childEntryList.	+
−
	}+
−
+
−
+
−
+
−
/**+
−
 * GetNextAvailableDriveId()+
−
 * +
−
 * This function is added in PREQ 557.+
−
 * @param None: +
−
 * @return TUint: The next available drive Id.+
−
 * +
−
 */+
−
TUint CMsvIndexAdapter::GetNextAvailableDriveId()+
−
	{+
−
	TMsvPreferredDrive driveEntry;+
−
	TUint driveId = iFirstFreeDriveId;+
−
	for(TUint index=0; index<8; index++)+
−
		{+
−
		TBool driveIdFound = EFalse;+
−
		CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();+
−
		for(TInt index=0; index<driveList->Count(); ++index)+
−
			{+
−
			driveEntry = (*driveList)[index];+
−
			if(driveId == driveEntry.driveId)+
−
				{+
−
				driveIdFound = ETrue;+
−
				break;+
−
				}+
−
			}+
−
		if(EFalse == driveIdFound)+
−
			{+
−
			iFirstFreeDriveId = ((driveId)%7 ? (driveId+1) : 2);+
−
			return driveId;+
−
			}+
−
		driveId = ((driveId)%7 ? (driveId+1) : 2);+
−
		}+
−
	return KErrNone;+
−
	}+
−
	+
−
	+
−
+
−
/**+
−
 * ReloadCacheL()+
−
 * +
−
 * This function is used by backup and restore functionality+
−
 * when it finds that DB being restored is changed. The function+
−
 * destroys the cache of the current drive and recreates it.+
−
 */+
−
void CMsvIndexAdapter::ReloadCacheL()+
−
	{+
−
	TUint currDriveIndex = CMsvPreferredDriveList::GetDriveList()->CurrentDriveIndex();+
−
	TDriveNumber currDriveNum = CMsvPreferredDriveList::GetDriveList()->CurrentDriveNumber();+
−
+
−
	// Attach the database.+
−
	TMsvId maxId;+
−
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)+
−
	TRAPD(err, iDbAdapter->AttachDBL(currDriveNum, KCurrentDriveId, maxId, &iServer.MessageDBAdapter()));+
−
#else+
−
	TRAPD(err, iDbAdapter->AttachDBL(currDriveNum, KCurrentDriveId, maxId));+
−
#endif+
−
	WrapDBErrorL(err);+
−
	+
−
	// Update the entry in drive list.+
−
	CMsvPreferredDriveList::GetDriveList()->UpdateDriveStatusL(currDriveIndex, EMsvMessageStoreAvailableStatus);+
−
+
−
	// Insert the max Id in the list.+
−
	iMaxMsvIdList[KCurrentDriveId] = ((maxId >= MaskTMsvId(KCurrentDriveId, KFirstFreeEntryId))? (maxId+1) : MaskTMsvId(KCurrentDriveId, KFirstFreeEntryId));		+
−
+
−
	TMsvId folderId = MaskTMsvId(KCurrentDriveId, KMsvRootIndexEntryId);+
−
	+
−
	// Add local service folder node in the folder list.+
−
	iRootNode = CMsvCacheVisibleFolder::NewL(folderId);+
−
	iFolderListHeader.AddFirst(*iRootNode);+
−
	+
−
	// Fetch children of root folder to cache.+
−
	RPointerArray<CMsvCacheEntry> childEntryList;+
−
	CleanupClosePushL(childEntryList);+
−
	+
−
	// Updating children under root node.	+
−
	TRAP(err, iDbAdapter->GetChildrenL(folderId, childEntryList));+
−
	WrapDBErrorL(err);+
−
	iRootNode->AddEntryListL(childEntryList, ETrue);+
−
	childEntryList.Reset();	+
−
+
−
	// Create a local service node and its children.+
−
	folderId = MaskTMsvId(KCurrentDriveId, KMsvLocalServiceIndexEntryId);+
−
	+
−
	// Add local service folder node in the folder list.+
−
	CMsvCacheVisibleFolder* localServiceFolder = CMsvCacheVisibleFolder::NewL(folderId);+
−
	iFolderListHeader.AddFirst(*localServiceFolder);+
−
	+
−
	// Fetch children of localService folder to cache.+
−
	TRAP(err, iDbAdapter->GetChildrenL(folderId, childEntryList));+
−
	WrapDBErrorL(err);+
−
	localServiceFolder->AddEntryListL(childEntryList, ETrue);+
−
+
−
	CleanupStack::PopAndDestroy();   // childEntryList.+
−
	}+
−
#endif 		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
+
−
+
−
+
−
+
−
#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)+
−
#ifdef _DEBUG+
−
void CMsvIndexAdapter::PrintL()+
−
	{+
−
	_LIT8(KFolderId, "FOLDER ID: ");+
−
	_LIT8(KDriveId, "      DRIVE ID: ");+
−
	_LIT8(KComplete, "      COMPLETE FLAG: ");+
−
	_LIT8(KFalse, "FALSE.");+
−
	_LIT8(KTrue, "TRUE.");+
−
	+
−
	RFileLogger logger;+
−
	CleanupClosePushL(logger);+
−
	if (logger.Connect() == KErrNone)+
−
		{+
−
		logger.CreateLog(_L("msgs"), _L("Cache.txt"), EFileLoggingModeAppend);+
−
		logger.SetDateAndTime(EFalse, EFalse);+
−
		logger.Write(_L(" Message Index Cache Structure."));+
−
		logger.Write(_L("--------------------------------"));+
−
		logger.Write(_L(""));+
−
		}+
−
	+
−
	CMsvCacheVisibleFolder* folderNode = NULL;+
−
	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);+
−
+
−
	dqIter.SetToFirst();+
−
	while((folderNode = dqIter++)!=NULL)+
−
		{+
−
		RBuf8 text;+
−
		CleanupClosePushL(text);+
−
		text.CreateL(100);+
−
		text.Append(KFolderId);+
−
		text.AppendNum(folderNode->GetFolderId());+
−
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)+
−
		text.Append(KDriveId);+
−
		text.AppendNum(folderNode->GetDrive());+
−
#endif+
−
		text.Append(KComplete);+
−
		if(folderNode->IsComplete())+
−
			{+
−
			text.Append(KTrue);+
−
			}+
−
		else+
−
			{+
−
			text.Append(KFalse);+
−
			}+
−
		logger.Write(text);+
−
		CleanupStack::PopAndDestroy();  // text+
−
		folderNode->Print(logger);+
−
		logger.Write(_L(""));		+
−
		}+
−
	logger.CloseLog();+
−
	CleanupStack::PopAndDestroy();  // logger+
−
	}+
−
#endif			// #ifdef _DEBUG	+
−
#endif			// #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)+
−
	+
−