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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifdef _DEBUG

    17 #undef _NO_SERVER_LOGGING_

    18 #endif

    19 

    20 /**

    21  * User Includes

    22  */

    23 #include "MSVSERV.H"

    24 #include "MSVARRAY.H"

    25 #include "msvdbadapter.h"

    26 #include "msvcacheentry.h"

    27 #include "msvindexadapter.h"

    28 #include "msventryfreepool.h"

    29 #include "msvcachevisiblefolder.h"

    30 #include "msvsearchsortdeltacache.h"

    31 #include "msvsearchsortcachemanager.h"

    32 

    33 /**

    34  *System Includes

    35  */

    36 #include <msvuids.h>

    37 #include <msvstd.h>

    38 

    39 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

    40 #include "msvconsts.h"

    41 #endif

    42 

    43 /**

    44  * MACRO DEFINITIONS

    45  */

    46 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

    47 	#define INITIAL_NUM_ENTRIES 10

    48 #else

    49 	#define INITIAL_NUM_ENTRIES 13

    50 #endif

    51 

    52 /**

    53  * CONSTANT DEFINITIONS

    54  */

    55 const TInt KMsvMtmListGranularity=8;

    56 const TInt KMsvChangeAttributesListGranularity=32;

    57 

    58 

    59 

    60 /**

    61  * FUNCTION DEFINITIONS

    62  */

    63 

    64 

    65 

    66 /**

    67  * CMsvIndexAdapter()

    68  */

    69 CMsvIndexAdapter::CMsvIndexAdapter(CMsvServer& aServer)

    70     :CActive(EPriorityStandard), iServer(aServer), iFolderListHeader(CMsvCacheVisibleFolder::iOffset)

    71 	{	

    72 	CActiveScheduler::Add(this);		

    73 	}

    74 

    75 

    76 

    77 

    78 /**

    79  * ~CMsvIndexAdapter()

    80  */

    81 CMsvIndexAdapter::~CMsvIndexAdapter()

    82 	{

    83 

    84 #ifndef _NO_SERVER_LOGGING_

    85 	iServer.Log(_L("Destroying CMsvIndexAdapter object."));

    86 #endif

    87 	

    88 	Cancel();

    89 	

    90 	// 1. Close the database.

    91 #ifndef _NO_SERVER_LOGGING_

    92 	iServer.Log(_L("Closing the database."));

    93 #endif

    94 	if(iDbAdapter != NULL)

    95 		delete iDbAdapter;

    96 

    97 	// 2. Delete Cache.

    98 #ifndef _NO_SERVER_LOGGING_

    99 	iServer.Log(_L("Destroying Cache."));

   100 #endif

   101 	

   102 	CMsvCacheVisibleFolder* folderNode = NULL;

   103 	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);

   104 

   105     dqIter.SetToFirst();

   106     while ((folderNode = dqIter++) != NULL)

   107         {

   108         folderNode->iDlink.Deque();

   109         delete folderNode;

   110         }

   111     

   112     iFreePoolInstance->ReleaseEntry(iRootEntry);

   113     iRootEntry = NULL;

   114 

   115     // 3. Delete internal data structure.

   116     iNonCommittedAddedEntryList.ResetAndDestroy();

   117     iNonCommittedChangedEntryList.Reset();

   118     iNonCommittedAddedEntryList.Close();

   119 	iNonCommittedChangedEntryList.Close();

   120     

   121     // 4. Flush extra memory in entry freepool.

   122     if(iFreePoolInstance != NULL)

   123     	{

   124     	iFreePoolInstance->FlushExcessMemory();	

   125     	}

   126 	

   127 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   128 	// Added for 557.

   129 	iMaxMsvIdList.Close();

   130 #endif

   131 

   132 	delete iIdle;

   133 	}

   134 

   135 

   136 

   137 

   138 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   139 /**

   140  * NewL()

   141  * @return The newly created index adapter object.

   142  * 

   143  * Function added as part of PREQ 557.

   144  * It returns an instance of CMsvIndexAdapter class. 

   145  */

   146 CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer)

   147 	{

   148 	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);

   149 	CleanupStack::PushL(self);

   150 	

   151 	self->ConstructL();

   152 	

   153 	CleanupStack::Pop();

   154 	return self;

   155 	}

   156 

   157 

   158 

   159 

   160 /**

   161  * ConstructL()

   162  * 

   163  * Function added as part of PREQ 557.

   164  * The function is called from NewL().

   165  * 1. Create the DB adapter object.

   166  * 2. Initialize freepool object.

   167  * 3. Create the root entry in cache.

   168  * 4. Browse through the preferred drive list.

   169  *    i. For each drive in the preferred drive list the function 

   170  *       assigns a unique drive-id (0< Id <8).

   171  *	 ii. Attach the DB to the primary database.

   172  *  iii. Update the maxId of the database to MaxId table.

   173  *   iv. If the database is not compatible or corrupt, update the 

   174  *       appropriate drive status in CMsvServer data structure.

   175  *    v. Fetch children of root entry and Local-Service entry from the DB to the cache.      

   176  */

   177 void CMsvIndexAdapter::ConstructL()

   178 	{

   179 #ifndef _NO_SERVER_LOGGING_

   180 	iServer.Log(_L("Inside ConstructL()..."));

   181 #endif

   182 	

   183 	// Create database adapter object.

   184 	iDbAdapter = CMsvDBAdapter::NewL();

   185 		

   186 #ifndef _NO_SERVER_LOGGING_

   187 	iServer.Log(_L("The database object is created succesfully."));

   188 #endif

   189 	

   190 	iProgress.iCompleted = 0;

   191 	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;

   192 	

   193 	// Initialize freepool object.

   194 	iFreePoolInstance = CMsvEntryFreePool::Instance();

   195 	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

   196 	

   197 	// Drive id zero will be synonym of KCurrentDriveId. Drive

   198 	// id of a drive (including current) drive will never be zero.

   199 	// Drive of the current drive will always by KCurrentDriveId.

   200 	TUint driveId = KCurrentDriveId;

   201 

   202 	// Since driveId starts from 1, the first 

   203 	// entry in iMaxMsvIdList is not used.

   204 	// Enter a dummy entry in location zero.

   205 	iMaxMsvIdList.InsertL(0, 0);

   206 	

   207 	iProgress.iCompleted++;

   208 	iProgress.iRemaining--;

   209 	iProgress.iId = KMsvRootIndexEntryId;

   210 	

   211 	// For each drive in the preferred drive list, perform followings...

   212 	// 1. Check if a valid message store is available.

   213 	// 2. If not, skip the drive.

   214 	// 3. Assign a new drive Id to the drive and

   215 	//    update the entry in preferred drive list.

   216 	// 4. Attach the drive database to the primary DB.

   217 	// 5. Update the max Id list.

   218 	// 6. For current drive, fetch the children of root entry into cache.

   219 	// 7. Fetch children of localService into cache.

   220 	CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();

   221 	TUint curDriveIndex = driveList->CurrentDriveIndex();

   222 	for(TInt index=curDriveIndex; index<driveList->Count(); index++)

   223 		{

   224 		TMsvPreferredDrive driveEntry;

   225 		driveList->DriveInfoL(index, driveEntry);

   226 		

   227 		if(EMsvMessageStoreAvailableStatus == driveEntry.status)

   228 			{

   229 			// Assign a unique drive-id.

   230 			driveList->UpdateDriveIdL(index, driveId);

   231 			

   232 			// Attach the database.

   233 			TMsvId maxId;

   234 			iDbAdapter->AttachDBL(driveEntry.driveNum, driveId, maxId);

   235 			

   236 			// Insert the max Id in the list.

   237 			iMaxMsvIdList.InsertL( ((maxId >= MaskTMsvId(driveId, KFirstFreeEntryId))? (maxId+1): MaskTMsvId(driveId, KFirstFreeEntryId)), driveId);

   238 			driveId++;

   239 			}

   240 		iProgress.iCompleted++;

   241 		iProgress.iRemaining--;

   242 		}

   243 

   244 	iFirstFreeDriveId = (driveId%8)? (driveId%8): 2;

   245 

   246 	// Initializing remaining entries in MaxMsvId list.

   247 	for(TInt index=driveId; index<8; index++)

   248 		{

   249 		iMaxMsvIdList.InsertL(NULL, index);

   250 		}

   251 	

   252 	// For current drive fetch children of root entries also.

   253 	RPointerArray<CMsvCacheEntry> childEntryList;

   254 	CleanupClosePushL(childEntryList);	

   255 	// Create root entry node in the cache. A root folder node will never 

   256 	// be swapped out of cache. The children of root entry will be the 

   257 	// children of root entry in the current drive.

   258 	// Root id is masked to set the driveId in the folder node.

   259 	iRootNode = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvRootIndexEntryId));

   260 	iFolderListHeader.AddFirst(*iRootNode);

   261 	iRootNode->SetComplete(ETrue);

   262 	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childEntryList);

   263 	iRootNode->AddEntryListL(childEntryList, ETrue);

   264 	childEntryList.Reset();

   265 	

   266 	// Fetch child of LocalServices.

   267 	CMsvCacheVisibleFolder* localServiceFolder = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvLocalServiceIndexEntryId));

   268 	iFolderListHeader.AddFirst(*localServiceFolder);

   269 	iDbAdapter->GetChildrenL(KMsvLocalServiceIndexEntryId, childEntryList);

   270 	localServiceFolder->AddEntryListL(childEntryList, ETrue);

   271 	CleanupStack::PopAndDestroy(1);   //childEntryList

   272 		

   273 	// Create root entry.

   274 	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.

   275 	iRootEntry->Entry().iType = KUidMsvRootEntry;

   276 	iRootEntry->Entry().iDate.UniversalTime();

   277 	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);

   278 	iRootEntry->Entry().SetParent(KErrNotFound);

   279 	iRootEntry->Entry().SetOwner(ETrue);

   280 	iRootEntry->Entry().iSize = 0;

   281 	

   282 	// Update progress

   283 	iProgress.iCompleted = iProgress.iTotal;

   284 	iProgress.iRemaining = 0;

   285 	iProgress.iId = KMsvRootIndexEntryId;

   286 

   287 #ifndef _NO_SERVER_LOGGING_

   288 	iServer.Log(_L("Cache initialized succesfully."));

   289 #endif

   290 	

   291 	iIdle = CIdle::NewL(CActive::EPriorityIdle);

   292 	CompleteSelf();

   293 	}

   294 

   295 

   296 

   297 /**

   298 GetInPreparationIds

   299 */

   300 void CMsvIndexAdapter::GetInPreparationIds(CMsvEntrySelection& aSelection, TUint aDriveId /*DEFAULT = 0 */)

   301 	{

   302 	if(iDbAdapter)

   303 		{

   304 		TRAP_IGNORE(iDbAdapter->GetInPreparationIdL(aSelection, aDriveId));

   305 		}

   306 	}

   307 

   308 

   309 #else		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   310 

   311 

   312 /**

   313  * NewL()

   314  * @param TFileName: DB File Name.

   315  * @return The newly created index adapter.

   316  * 

   317  * It returns an instance of CMsvIndexAdapter class. 

   318  */

   319 CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer, const TFileName& aDbFileName)

   320 	{

   321 	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);

   322 	CleanupStack::PushL(self);

   323 	

   324 	self->ConstructNewL(aDbFileName);

   325 	

   326 	CleanupStack::Pop();

   327 	return self;

   328 	}

   329 

   330 

   331 

   332 

   333 /**

   334  * OpenL()

   335  * @param TFileName: DB File Name.

   336  * @return The newly created index adapter.

   337  * 

   338  * It returns an instance of CMsvIndexAdapter class. 

   339  */

   340 CMsvIndexAdapter* CMsvIndexAdapter::OpenL(CMsvServer& aServer, const TFileName& aDbFileName)

   341 	{

   342 	CMsvIndexAdapter *self = new(ELeave) CMsvIndexAdapter(aServer);

   343 	CleanupStack::PushL(self);

   344 	

   345 	self->ConstructOpenL(aDbFileName);

   346 	

   347 	CleanupStack::Pop();

   348 	return self;

   349 	}

   350 

   351 

   352 

   353 

   354 /**

   355  * ConstructNewL()

   356  * 

   357  * The function is called from NewL().

   358  * 1. Check if a database with the passed name already exists.

   359  * 1.1. If yes, open the database.

   360  * 1.2. If no, create a new database with the same name.

   361  * 2. Creates entry cache.

   362  * 3. If a new database is created, create root entry also.

   363  */

   364 void CMsvIndexAdapter::ConstructNewL(const TFileName& aDbFileName)

   365 	{

   366 #ifndef _NO_SERVER_LOGGING_

   367 	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));

   368 #endif

   369 	

   370 	// Delete the database first, if it already exists.

   371 	CMsvDBAdapter::DeleteDB(aDbFileName);

   372 	

   373 	// Get the instance of free pool.

   374 	iFreePoolInstance = CMsvEntryFreePool::Instance();

   375 

   376 	// Create the new database with the same name.

   377 	// If this leaves, nothing can be done and let NewL() leave.

   378 	iDbAdapter = CMsvDBAdapter::NewL(aDbFileName);

   379 #ifndef _NO_SERVER_LOGGING_

   380 	iServer.Log(_L("A new database %s is created..."), &aDbFileName);

   381 #endif

   382 	

   383 	iProgress.iTotal = iProgress.iRemaining = 1; //root

   384 	// Create root entry. 

   385 	CreateInitialSetOfEntriesL();

   386 	

   387 

   388 #ifndef _NO_SERVER_LOGGING_

   389 //	iServer.Log(_L("Cache initialized succesfully."));

   390 #endif

   391 	

   392 	iNextCreateId = KFirstFreeEntryId;

   393 	iIdle = CIdle::NewL(CActive::EPriorityIdle);

   394 	CompleteSelf();

   395 	}

   396 		

   397 

   398 

   399 

   400 	

   401 /**

   402  * ConstructOpenL()

   403  * 

   404  * The function is called from NewL().

   405  * 1. Check if a database with the passed name already exists.

   406  * 1.1. If yes, open the database.

   407  * 1.2. If no, create a new database with the same name.

   408  * 2. Creates entry cache.

   409  * 3. If a new database is created, it then read message resource file 

   410  *    and creates entry as mentioned in cache and database.

   411  */

   412 void CMsvIndexAdapter::ConstructOpenL(const TFileName& aDbFileName)

   413 	{

   414 #ifndef _NO_SERVER_LOGGING_

   415 	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));

   416 #endif

   417 	

   418 	// Get the instance of free pool

   419 	iFreePoolInstance = CMsvEntryFreePool::Instance();

   420 

   421 	// Open the database.

   422 	iDbAdapter = CMsvDBAdapter::OpenL(aDbFileName);

   423 	

   424 #ifndef _NO_SERVER_LOGGING_

   425 	iServer.Log(_L("Opening database %s is succesful."), &aDbFileName);

   426 #endif

   427 		

   428 	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;	

   429 	CreateInitialCacheL();

   430 

   431 #ifndef _NO_SERVER_LOGGING_

   432 	iServer.Log(_L("Cache initialized succesfully."));

   433 #endif

   434 

   435 	TMsvId tmpNextId = NULL;

   436 	iDbAdapter->GetMaxTMsvIdL(tmpNextId);

   437 	iNextCreateId = (tmpNextId >= KFirstFreeEntryId)? (tmpNextId+1) : KFirstFreeEntryId;

   438 	

   439 	iIdle = CIdle::NewL(CActive::EPriorityIdle);

   440 	CompleteSelf();

   441 	}

   442 	

   443 

   444 

   445 

   446 /**

   447  * CreateInitialSetOfEntries()

   448  * 

   449  * The function is called from ConstructL(), whenever a new DB is created.

   450  * The function creates root entry into database and cache.

   451  */

   452 void CMsvIndexAdapter::CreateInitialSetOfEntriesL()

   453 	{

   454 	

   455 #ifndef _NO_SERVER_LOGGING_

   456 	iServer.Log(_L("Inside CreateInitialSetOfEntriesL(): Creating standard entries for new DB."));

   457 #endif

   458 	

   459 	// 1. Initialize the instance of free pool.

   460 	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

   461 		

   462 	// 2. Creating root entry into database.

   463 	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.

   464 	iRootEntry->Entry().iType = KUidMsvRootEntry;

   465 	iRootEntry->Entry().iDate.UniversalTime();

   466 	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);

   467 	iRootEntry->Entry().SetParent(KErrNotFound);

   468 	iRootEntry->Entry().iSize = 0;

   469 	

   470 	TMsvId visibleFolderId = KMsvRootIndexEntryId;

   471 	iDbAdapter->CreateEntryL(iRootEntry->Entry(), visibleFolderId);

   472 	

   473 	// 3. Add root entry to cache as well

   474 	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);

   475 	iFolderListHeader.AddFirst(*rootFolder);

   476 	rootFolder->SetComplete(ETrue);

   477 	

   478 	// Update progress

   479 	iProgress.iCompleted++;

   480 	iProgress.iRemaining--;

   481 	iProgress.iId = KMsvRootIndexEntryId;

   482 	}

   483 

   484 

   485 

   486 

   487 

   488 /**

   489  * CreateInitialCache()

   490  * 

   491  * The function is called from NewL(), whenever an existing DB is opened.

   492  * It creates the intial cache. It creates root entry in cache and fetches

   493  * child of root from DB and push them into cache. It then fetches child

   494  * entries of LocalServices and push them too into cache. 

   495  * 

   496  * >>>> The function can be enhanced to load children of additional folders

   497  * to cache along with the above standard folders. These additional folders 

   498  * can be mentioned by licensees in msgs.ini file.

   499  */

   500 void CMsvIndexAdapter::CreateInitialCacheL()

   501 	{

   502 #ifndef _NO_SERVER_LOGGING_

   503 	iServer.Log(_L("Inside CreateInitialCache(): Initializing Cache."));

   504 #endif

   505 

   506 	//1. Initialize the instance of free pool.

   507 	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

   508 	

   509 	// 2. Add root entry to cache.

   510 	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);

   511 	iFolderListHeader.AddFirst(*rootFolder);

   512 	// 2.1 Update progress

   513 	iProgress.iCompleted++;

   514 	iProgress.iRemaining--;

   515 	iProgress.iId = KMsvRootIndexEntryId;

   516 	

   517 	// 3. Fetch child of root entries from DB.

   518 	RPointerArray<CMsvCacheEntry> childrenOfRoot;

   519 	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childrenOfRoot);

   520 

   521 	// 3.1 Get the root entry from DB.

   522 	CMsvCacheEntry *rootEntry = NULL;

   523 	TMsvId visibleFolder = NULL;

   524 	iDbAdapter->GetEntryL(KMsvRootIndexEntryId, rootEntry, visibleFolder);

   525 	// 3.2 Copy the TMsvEntry of root from CMsvCacheEntry.

   526 	//Mem::Copy(&iRootEntry->Entry(), &rootEntry->Entry(), sizeof(TMsvEntry));

   527 	iRootEntry = rootEntry;

   528 	// 3.3 Release the cache entry back to the freepool.

   529 	//iFreePoolInstance->ReleaseEntry(rootEntry);	

   530 	

   531 	// 4. Add children to cache.

   532 	rootFolder->AddEntryListL(childrenOfRoot, ETrue);

   533 	// 4.1 Update progress

   534 	iProgress.iCompleted += 4;

   535 	iProgress.iRemaining -= 4;

   536 	iProgress.iId = KMsvLocalServiceIndexEntryId;

   537 	

   538 	// 5. Set the visible folder as complete

   539 	rootFolder->SetComplete(ETrue);

   540 	

   541 	

   542 	// 6. Fetch child of LocalServices

   543 	childrenOfRoot.Reset();

   544 	iDbAdapter->GetChildrenL(KMsvLocalServiceIndexEntryId, childrenOfRoot);

   545 	

   546 	CMsvCacheVisibleFolder* localFolder = CMsvCacheVisibleFolder::NewL(KMsvLocalServiceIndexEntryId);

   547 	iFolderListHeader.AddFirst(*localFolder);

   548 		

   549 	// 7. Add children to cache.

   550 	localFolder->AddEntryListL(childrenOfRoot);

   551 	// 7.1 Update progress

   552 	iProgress.iCompleted = iProgress.iTotal;

   553 	iProgress.iRemaining = 0;

   554 	iProgress.iId = KMsvGlobalInBoxIndexEntryId;

   555 	

   556 	// 8. Set the visible folder as complete

   557 	localFolder->SetComplete(ETrue);

   558 	childrenOfRoot.Close();

   559 	}

   560 	

   561 

   562 

   563 /**

   564 GetInPreparationIds

   565 */

   566 void CMsvIndexAdapter::GetInPreparationIds(CMsvEntrySelection& aSelection)

   567 	{

   568 	if(iDbAdapter)

   569 		{

   570 		TRAP_IGNORE(iDbAdapter->GetInPreparationIdL(aSelection));

   571 		}	

   572 	}

   573 

   574 

   575 #endif 		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   576 

   577 

   578 /**

   579  *CompleteSelf

   580  *This will make sure that Runl is called.

   581  */

   582 void CMsvIndexAdapter::CompleteSelf()

   583 	{

   584 	iStatus=KRequestPending;

   585 	SetActive();

   586 	TRequestStatus* st=&iStatus;

   587 	User::RequestComplete(st, KErrNone);

   588 	}

   589 

   590 

   591 

   592 /**

   593  * RunL()

   594  */

   595 void CMsvIndexAdapter::RunL()

   596 	{

   597 	// Set the state for the background state machine.

   598 	iBackgroundOperationState = ERemoveDeletedEntries;

   599 	iBackgroundOperationPerformed = 0;

   600 	}

   601 	

   602 

   603 

   604 

   605 /**

   606  * DoCancel()

   607  */

   608 void CMsvIndexAdapter::DoCancel()

   609 	{

   610 	iIdle->Cancel();	

   611 	}

   612 

   613 

   614 

   615 

   616 /**

   617  * AddEntry()

   618  */

   619 TInt CMsvIndexAdapter::AddEntry(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId)

   620 	{

   621 	TRAPD(err, DoAddEntryL(aEntry, aOwnerId, aAutoAssignId));

   622 	return err;

   623 	}

   624 

   625 

   626 /**

   627  * AddEntryNoCommit()

   628  */

   629 TInt CMsvIndexAdapter::AddEntryNoCommit(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId)

   630 	{

   631 	if(iDbAdapter)

   632 		{

   633 		TRAP_IGNORE(iDbAdapter->BeginTransactionL());

   634 		}

   635 	else

   636 		{

   637 		return ErrorState();

   638 		}

   639 	TRAPD(err, DoAddEntryL(aEntry, aOwnerId, aAutoAssignId, EFalse));

   640 	if(err)

   641 		{

   642 		RollbackAdditions();

   643 		}

   644 	return err;

   645 	}

   646 

   647 

   648 

   649 /**

   650  * DoAddEntryL()

   651  * 

   652  * Add the entry to the index and then the file. 

   653  * If either fails the function leaves. Creates 

   654  * its own copy of TMsvEntry (SetEntryL() code). 

   655  * This can be optimized further.

   656  */

   657 void CMsvIndexAdapter::DoAddEntryL(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aAutoAssignId, TBool aCommitToDb)

   658 	{

   659 	// Leave if the message store is not currently available.

   660     User::LeaveIfError(iErrorState);

   661     

   662 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   663 	// get and set the unique id

   664 	if (aAutoAssignId)

   665 		{

   666 		aEntry.SetId(NextId(GetDriveId(aEntry.Parent())));

   667 		}

   668 

   669 	if (aEntry.iType == KUidMsvServiceEntry)

   670 		{

   671 		if(KMsvLocalServiceIndexEntryId == UnmaskTMsvId(aEntry.iId))

   672 			{

   673 			aEntry.iServiceId = KMsvLocalServiceIndexEntryId;

   674 			}

   675 		else

   676 			{

   677 			aEntry.iServiceId = aEntry.Id();

   678 			}

   679 		}

   680 #else		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   681 	if (aAutoAssignId)

   682 		{

   683 		aEntry.SetId(NextId());

   684 		}

   685 

   686 	if (aEntry.iType == KUidMsvServiceEntry)

   687 		{

   688 		aEntry.iServiceId = aEntry.Id();

   689 		}

   690 #endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   691 

   692 	CMsvCacheEntry* parentEntry = NULL;

   693 	FindEntryL(aEntry.Parent(), parentEntry);

   694 

   695 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   696 	if(UnmaskTMsvId(aEntry.iId) == KMsvDeletedEntryFolderEntryId)

   697 		{

   698 		aEntry.SetVisibleFolderFlag(ETrue);

   699 		}

   700 	else	

   701 #endif

   702 		{		

   703 		// If entry is set to visible while creation, then set the visible folder

   704 		// flag to ETrue, this will not change for the lifetime of an TMsvEntry.

   705 		if(parentEntry->Entry().VisibleFolderFlag())

   706 			{

   707 			if( (aEntry.Visible()) && 

   708 			    (aEntry.iType == KUidMsvFolderEntry || aEntry.iType == KUidMsvServiceEntry)

   709 			  )

   710 				{

   711 				aEntry.SetVisibleFolderFlag(ETrue);

   712 				}

   713 			else

   714 				{

   715 				aEntry.SetVisibleFolderFlag(EFalse);

   716 				}				

   717 			}

   718 		else

   719 			{

   720 			aEntry.SetVisibleFolderFlag(EFalse);

   721 			}

   722 		}

   723 		

   724 	aEntry.SetOwner(EFalse);

   725 	TMsvId visibleFolderId;

   726 	if(!GetVisibleFolderId(aEntry.Parent(), visibleFolderId))

   727 		{

   728 		User::Leave(KErrNotFound);

   729 		}

   730     

   731 	// Add entry to cache.      

   732     CMsvCacheEntry* newCacheEntry = NULL;   

   733     newCacheEntry = iFreePoolInstance->EntryL();

   734     // Set the owner ID of the entry - the SID of the owning process.

   735     newCacheEntry->SetEntryOwnerId(aOwnerId);

   736     

   737     CMsvCacheVisibleFolder* visibleFolder = NULL;

   738     TRAPD(err, newCacheEntry->SetEntryL(aEntry);

   739                visibleFolder = AddEntryToCacheL(visibleFolderId, newCacheEntry);

   740          );

   741     if(err)

   742         {

   743         iFreePoolInstance->ReleaseEntryWithoutTransaction(newCacheEntry);

   744         User::Leave(err);

   745         }

   746 

   747 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   748     TRAP(err,

   749             if(aCommitToDb)

   750                 iDbAdapter->BeginTransactionL();

   751             iDbAdapter->CreateEntryL(aEntry, visibleFolderId);

   752             // Set the owner flag of parent entry if not already done.

   753             // For standard entry created from indexContext, parent Id will not be masked.

   754             iDbAdapter->UpdateOwnerStatusL(MaskTMsvId(GetDriveId(aEntry.iId), aEntry.Parent()), parentEntry->Entry(), ETrue);

   755             if(aCommitToDb)

   756                 iDbAdapter->CommitTransactionL();

   757         );

   758 #else

   759     TRAP(err,

   760             if(aCommitToDb)

   761                 iDbAdapter->BeginTransactionL();

   762             iDbAdapter->CreateEntryL(aEntry, visibleFolderId);

   763             // Set the owner flag of parent entry if not already done.

   764             // For standard entry created from indexContext, parent Id will not be masked.

   765             iDbAdapter->UpdateOwnerStatusL(aEntry.Parent(), parentEntry->Entry(), ETrue);

   766             if(aCommitToDb)

   767                 iDbAdapter->CommitTransactionL();

   768         );

   769 #endif  

   770     if(err & KSqlErrConstraint != err)

   771         {

   772         if(aCommitToDb)

   773             iDbAdapter->RollbackTransactionL();

   774         // This will not leave...

   775         TRAP_IGNORE(visibleFolder->DeleteEntryL(newCacheEntry->GetId()));

   776         User::Leave(err);

   777         }	

   778 	parentEntry->Entry().SetOwner(ETrue);

   779 

   780 	if(!aCommitToDb)

   781 		{

   782 		// Add entry to the list of non-committed entries.

   783 		CNonCommittedAddedEntries* nonCommittedAddedEntries = new(ELeave)CNonCommittedAddedEntries(visibleFolderId, newCacheEntry);

   784 		CleanupStack::PushL(nonCommittedAddedEntries);

   785 		iNonCommittedAddedEntryList.AppendL(nonCommittedAddedEntries);

   786 		CleanupStack::Pop(nonCommittedAddedEntries);

   787 		}

   788 

   789 	if(aEntry.iType.iUid == KUidMsvMessageEntryValue && CMSvSearchSortCacheManager::Instance()->iManagerEntry != NULL)

   790 		{	

   791 		TMsgType aType(ENewMsg);

   792 		if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0)

   793 			{

   794 			CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aEntry.Id(),aType);

   795 			}

   796 		}	

   797 	}

   798 	

   799 	

   800 

   801 

   802 /**

   803  * GetVisibleFolderId()

   804  * 

   805  * Returns ETrue, if the parent entry exists. Otherwise returns EFalse.

   806  * IN: Parent Id of the entry, whose immediate visible folder has to be found.

   807  * OUT: Visible folder Id.

   808  */

   809 TBool CMsvIndexAdapter::GetVisibleFolderId(TMsvId aParentId, TMsvId& aVisibleFolderId)

   810 	{

   811 	// If the entry is either a root entry (parent=KErrNotFound) or 

   812 	// child of root entry its visibleFolderId will be root entry itself.

   813 	if((KErrNotFound == aParentId) || (KMsvRootIndexEntryId == aParentId))

   814 		{

   815 		aVisibleFolderId = KMsvRootIndexEntryId;

   816 		return ETrue;

   817 		}

   818 	

   819 	// Get the visible flag of parent entry.

   820 	

   821 	// If parent entry is visible, then immediateVisibleFolder of child

   822 	// should be parent Id. And if it is invisible then child's immediateVisibleFolder 

   823 	// should be same as parent's immediateVisibleFolder.

   824 	// First check in cache.

   825 	if(!iFolderListHeader.IsEmpty())

   826 		{

   827 		CMsvCacheVisibleFolder* folderNode = NULL;

   828 		TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);

   829 		dqIter.SetToFirst(); 

   830 		while((folderNode = dqIter++)!=NULL)

   831 			{

   832 			// Check if the current folder node is parent.

   833 			if( aParentId == folderNode->GetFolderId() )

   834 				{

   835 				aVisibleFolderId = aParentId;

   836 				return ETrue;

   837 				}

   838 			}

   839 		dqIter.SetToFirst(); 

   840 		CMsvCacheEntry* entry;

   841 		while((folderNode = dqIter++)!=NULL)

   842 			{

   843 			// Check if the current folder node is parent.

   844 			if(folderNode->GetEntry(aParentId, entry))

   845 				{

   846 				if(entry->Entry().VisibleFolderFlag())

   847 					{

   848 					aVisibleFolderId = aParentId;

   849 					}

   850 				else

   851 					{

   852 					//If the visible folder is not the parent, then

   853 					//the current folder must be the visible folder,

   854 					//as otherwise the parent would have been under another

   855 					//folder node.

   856 					aVisibleFolderId = folderNode->GetFolderId();

   857 					}

   858 				return ETrue;

   859 				}

   860 			}

   861 		}

   862 	

   863 	// Entry cannot be found in cache,

   864 	// Now search in DB.

   865 	TInt err = KErrNone;

   866 	if(iDbAdapter)

   867 		{

   868 		TRAP(err, iDbAdapter->GetVisibleFolderIdL(aParentId, aVisibleFolderId));

   869 		}

   870 	else

   871 		{

   872 		return EFalse;

   873 		}

   874 	if(KErrNone == err)

   875 		{

   876 		return ETrue; 		

   877 		}

   878 	return EFalse;		

   879 	}

   880 

   881 

   882 

   883 

   884 

   885 /**

   886  * DeleteEntry()

   887  */

   888 TInt CMsvIndexAdapter::DeleteEntry(TMsvId aId)

   889 	{

   890 	CMsvEntrySelection* selection = NULL;

   891 	

   892 	TRAPD(error, selection = new(ELeave)CMsvEntrySelection; selection->AppendL(aId););

   893 	if(KErrNone == error)

   894 		{

   895 		error = DeleteSelection(*selection);

   896 		}

   897 

   898 	TMsgType aType(EDeletedMsg);

   899 	if(CMSvSearchSortCacheManager::Instance()->iManagerEntry->Count()>0 && error == KErrNone)

   900 		{

   901 		CMsvSearchSortDeltaCache::Instance()->EntryInDeltaCache(aId,aType);

   902 		}

   903 

   904 	delete selection;

   905 	return error;

   906 	}

   907 

   908 

   909 

   910 

   911 

   912 /**

   913  * DeleteSelection

   914  * Deletes a selection of entries.

   915  *

   916  * @param aSelection Selection of TMsvIds of the entries to be deleted

   917  * @return TInt System-wide error code.

   918  */

   919 TInt CMsvIndexAdapter::DeleteSelection(const CMsvEntrySelection& aSelection)

   920 	{

   921 	TInt count = aSelection.Count();

   922 

   923 	if(!iDbAdapter)

   924 		{

   925 		return ErrorState();

   926 		}

   927 	// Only start a transaction if there are more than 1 entries to be deleted.

   928 	if(count > 1)

   929 		{

   930 		TRAP_IGNORE(iDbAdapter->BeginTransactionL());		

   931 		}

   932 	// If the transaction is opened, deleted

   933 	// entry will be released temporarily.

   934 	iFreePoolInstance->BeginTransaction();

   935 	TInt error = KErrNone;

   936 	TRAP(error, DoDeleteSelectionL(aSelection));

   937 	if (error)

   938 		{

   939 		if(count > 1)

   940 			{

   941 			TRAP_IGNORE(iDbAdapter->RollbackTransactionL());

   942 			}

   943 		iFreePoolInstance->RollbackTransaction();

   944 		}

   945 	else

   946 		{

   947 		if(count > 1)

   948 			{

   949 			TRAP_IGNORE(iDbAdapter->CommitTransactionL());

   950 			}	

   951 		iFreePoolInstance->CommitTransaction();

   952 		}

   953 	return error;

   954 	}

   955 

   956 

   957 

   958 

   959 

   960 /**

   961  * DoDeleteSelectionL

   962  */

   963 void CMsvIndexAdapter::DoDeleteSelectionL(const CMsvEntrySelection& aSelection)

   964 	{

   965 	User::LeaveIfError(iErrorState);

   966 	CMsvCacheVisibleFolder* folderNode = NULL;

   967 	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);

   968 	const TInt count = aSelection.Count();

   969 	if(count <= 0)

   970 		{

   971 		return;

   972 		}

   973 	

   974 	CMsvCacheEntry* entry = NULL;

   975 	TBool releaseEntry = FindEntryL(aSelection.At(0), entry, EFalse);

   976 	TMsvId parentId = entry->Entry().Parent();

   977 	if(releaseEntry)

   978 		{

   979 		iFreePoolInstance->ReleaseEntry(entry, ETrue);

   980 		}

   981 	CMsvEntrySelection* children = new(ELeave)CMsvEntrySelection;

   982 	CleanupStack::PushL(children);

   983 	

   984 	for (TInt index=0; index<count; ++index)

   985 		{

   986 		dqIter.SetToFirst(); 

   987 		TBool found = EFalse;

   988 		while((folderNode = dqIter++)!=NULL)

   989 			{

   990 			TRAPD(err, folderNode->DeleteEntryL(aSelection.At(index)));	

   991 			if(err != KErrNotFound && err != KErrNone)

   992 				{

   993 				User::Leave(err);

   994 				}

   995 			 else if(err == KErrNone)	

   996 			 	{

   997 			 	found = ETrue;

   998 			 	break;

   999 			 	}

  1000 			}

  1001 		if(!found)

  1002 			{

  1003 			if(iDbAdapter)

  1004 				{

  1005 				if(iDbAdapter->EntryExistsL(aSelection.At(index)))

  1006 					{

  1007 					User::Leave(KErrAccessDenied);

  1008 					}

  1009 				}

  1010 			else

  1011 				{

  1012 				User::Leave(ErrorState());	

  1013 				}

  1014 			User::Leave(KErrNotFound);

  1015 			}

  1016 		

  1017 		if(iDbAdapter)

  1018 			{

  1019 			iDbAdapter->DeleteEntryL(aSelection.At(index));

  1020 			}

  1021 		else

  1022 			{

  1023 			User::Leave(ErrorState());	

  1024 			}

  1025 		}

  1026 	//Find the parent entry in cache and check for any children.

  1027 	//If there are no more children under the parent, then

  1028 	//reset the owner flag in cache and database.

  1029 	TRAPD(err, releaseEntry = FindEntryL(parentId, entry, EFalse));

  1030 	//If parent was also deleted then nothing left to do.

  1031 	if(err == KErrNotFound)

  1032 		{

  1033 		CleanupStack::PopAndDestroy(); //children

  1034 		return;

  1035 		}

  1036 	TRAP(err, 

  1037 		GetChildrenIdL(parentId, *children);

  1038 		if(0 == children->Count() && entry->Entry().Owner())

  1039 			{

  1040 			if(iDbAdapter)

  1041 				{

  1042 				iDbAdapter->UpdateOwnerStatusL(parentId, entry->Entry(), EFalse);		

  1043 				}

  1044 			else

  1045 				{

  1046 				User::Leave(ErrorState());

  1047 				}

  1048 			entry->Entry().SetOwner(EFalse);

  1049 			}

  1050 		);

  1051 	// Release the entry, since it is not added to cache.

  1052 	if(releaseEntry)

  1053 		{

  1054 		iFreePoolInstance->ReleaseEntry(entry, ETrue);

  1055 		}

  1056 	User::LeaveIfError(err);

  1057 	CleanupStack::PopAndDestroy(); //children

  1058 	}

  1059 

  1060 

  1061 

  1062 

  1063 

  1064 /**

  1065  * ExpandSelectionRecursively()

  1066  * Expands a selection to include all the descendents of the entries. They are order

  1067  * in such a way that they can be deleted in order, children first

  1068  *

  1069  * @param aSelection CMsvEntrySelection, which contains the TMsvIds of the entry passed.

  1070  * @return TInt System wide error code.

  1071  */

  1072 TInt CMsvIndexAdapter::ExpandSelectionRecursively(CMsvEntrySelection& aSelection)

  1073 	{

  1074 	TInt error = KErrNone;

  1075 	iOrigEntryPos=0;

  1076 	iRecursionSelection=&aSelection;

  1077 	TInt count = aSelection.Count();

  1078 	while (iOrigEntryPos < count)

  1079 		{

  1080 		TMsvId entryId = aSelection.At(iOrigEntryPos);

  1081 		if( !EntryExists(entryId) )

  1082 			{

  1083 			error = KErrNotFound;

  1084 			aSelection.Delete(iOrigEntryPos);

  1085 			}

  1086 		else

  1087 			{

  1088 			// if the entry has children

  1089 			CMsvEntrySelection* children = NULL;

  1090 			TRAPD(err, children = new (ELeave)CMsvEntrySelection);

  1091 			if(KErrNone != err)

  1092 				{

  1093 				return err;

  1094 				}

  1095 			TInt leave = KErrNone;

  1096 			TRAP(leave, GetChildrenIdL(entryId, *children));

  1097 			if(KErrNone != leave)

  1098 				{

  1099 				delete children;

  1100 				return leave;				

  1101 				}

  1102 			TInt count = children->Count();

  1103 			for(TInt index=0; index<count; ++index)

  1104 				{

  1105 				iRecursionIndex = iOrigEntryPos;

  1106 				TRAP(leave, DoExpandSelectionRecursivelyL(children->At(index)));

  1107 				if(KErrNone != leave)

  1108 					{

  1109 					delete children;

  1110 					return leave;

  1111 					}

  1112 				}

  1113 			delete children;	

  1114 			++iOrigEntryPos;

  1115 			}

  1116 		}

  1117 	return error;

  1118 	}

  1119 

  1120 

  1121 

  1122 

  1123 

  1124 /**

  1125  * DoExpandSelectionRecursivelyL

  1126  * Expands a selection to include all the descendents of the entry with TMsvId aId. 

  1127  *

  1128  * @param aId TMsvId of the entire

  1129  * @return void

  1130  */

  1131 void CMsvIndexAdapter::DoExpandSelectionRecursivelyL(TMsvId aId)

  1132 	{

  1133 	// include this entry

  1134 	iRecursionSelection->InsertL(iRecursionIndex,aId);