1 // Copyright (c) 2004-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 /**

    17  @file

    18  @internalComponent

    19  @released

    20 */

    21 

    22 #include <s32mem.h>

    23 #include <cntitem.h>

    24 #include <cntdb.h>

    25 #include <cntfilt.h>

    26 

    27 #include "rcntmodel.h"

    28 #include "persistencelayer.h" // For MLplCollection.

    29 #include "CCntNotificationMonitor.h"

    30 #include "ccontactprivate.h" // For MProgressEventHander.

    31 #include "CCntPackager.h"

    32 #include <cntviewstore.h>

    33 

    34 

    35 /** Contacts server version number. */ 

    36 const TInt KCntServerMajorVersionNumber=1;

    37 const TInt KCntServerMinorVersionNumber=1;

    38 const TInt KCntServerBuildVersionNumber=1;

    39 

    40 /** Number of attempts to try restart the server after premature termination. */

    41 const TInt KMaxTimesToRestartServer = 3;

    42 

    43 /** Maximum number of asynchronous IPC calls. */

    44 const TInt KAsyncMessageSlots=6;

    45 

    46 

    47 /**

    48 Unlock the last locked contact item on the server.  Used by OpenLX().  If any

    49 method which locks a contact item leaves thenccnt this method is called as the

    50 cleanup stack unwinds, removing the lock for the last locked contact item.

    51 

    52 @capability None

    53 */

    54 void CleanupUnlockRecord(TAny *aSession)

    55 	{

    56 	static_cast<RCntModel*>(aSession)->UnlockLastLockedContact();

    57 	}

    58 

    59 

    60 /**

    61 Unlock the last locked contact item on the server.  Used by OpenLX().

    62 

    63 @capability None

    64 */

    65 void RCntModel::UnlockLastLockedContact()

    66 	{

    67 	CloseContact(KNullContactId);

    68 	}

    69 

    70 

    71 /**

    72 Push a Contact item unlock cleanup item on the cleanup stack.

    73 */

    74 void RCntModel::PushUnlockL() const

    75 	{

    76 	CleanupStack::PushL( TCleanupItem(CleanupUnlockRecord, const_cast<RCntModel *>(this)));

    77 	}

    78 

    79 

    80 /**

    81 RCntModel constructor.

    82 

    83 Member variables must be initialised (zero'd) in the constructor since

    84 RCntModel does not derive from CBase.

    85 */

    86 RCntModel::RCntModel()

    87 	:

    88 	iDbNotifyMonitor(NULL), 

    89 	iPackager(NULL),

    90 	iConnectionId(0),

    91 	iNoOfSvrStartAttempts(0)

    92 	{

    93 	}

    94 

    95 

    96 /**

    97 Get the Contacts server version number.

    98 

    99 @return Contacts server version number.

   100 */

   101 TVersion RCntModel::Version() const

   102 	{

   103 	return(TVersion(KCntServerMajorVersionNumber,KCntServerMinorVersionNumber,KCntServerBuildVersionNumber));

   104 	}

   105 

   106 

   107 /** Name of the executable for the Contacts server. */

   108 _LIT(KCntServerExe,"CNTSRV.EXE");

   109 /** Name used to connect a session to the Contacts server. */

   110 _LIT(KCntServerName,"CNTSRV");

   111 

   112 

   113 /**

   114 Open a Contacts server session.

   115 */

   116 void RCntModel::ConnectL()

   117 	{

   118 	// Assume the server is already running and attempt to create a session

   119 	// with a maximum of KAsyncMessageSlots message slots.

   120 	TInt err = CreateSession(KCntServerName,Version(),KAsyncMessageSlots);

   121 	

   122 	if(err == KErrNotFound) // Server not running?

   123 		{

   124 		// Use the RProcess API to start the server.

   125 		RProcess server;

   126 		User::LeaveIfError(server.Create(KCntServerExe,KNullDesC));

   127 		

   128 		//Enforce server to be at system default priority EPriorityForeground

   129 		//Contact server used to set as EPriorityHigh and this caused client could

   130 		//not get control or responsive until sorting by the idle sorter in remote 

   131 		//view was done.

   132 		server.SetPriority(EPriorityForeground);

   133 		

   134 		// Synchronise with the server.

   135 		TRequestStatus reqStatus;

   136 		server.Rendezvous(reqStatus);

   137 		server.Resume();

   138 		

   139 		// Server will call the reciprocal static synchronisation call.

   140 		User::WaitForRequest(reqStatus);

   141 		server.Close();

   142 		User::LeaveIfError(reqStatus.Int());

   143 		

   144 		// Create the server session.

   145 		User::LeaveIfError(CreateSession(KCntServerName,Version(),KAsyncMessageSlots));

   146 		}

   147 	else

   148 		{

   149 		User::LeaveIfError(err);

   150 		}

   151 

   152 	// Create object packer/unpacker if it doesn't already exist.

   153 	if (iPackager == NULL)	

   154 		{

   155 		iPackager = CCntPackager::NewL();

   156 		}

   157 	

   158 	// Each session (client) will be given a unique ID known as the Connection

   159 	// ID.  This ID forms part of the database event notification message.  This

   160 	// ID is created during the connection to the server.

   161 	ConnectionId();

   162 	}

   163 

   164 	

   165 /**

   166 Close session.

   167 */

   168 void RCntModel::Close()

   169 	{

   170 	delete iPackager;

   171 	iPackager = NULL;

   172 	delete iDbNotifyMonitor;

   173 	iDbNotifyMonitor = NULL;

   174 	RHandleBase::Close();

   175 	}

   176 

   177 

   178 /**

   179 Open a named contact database.

   180 

   181 Opens the default contacts database if the default argument is used.  The given

   182 descriptor must not contain more than KCntMaxFilePath characters.

   183 

   184 @param aCntFile Filename (in the form drive:database).  Defaults to

   185 KCntDefaultDrive.

   186 

   187 @return KErrNone if success, KErrArgument if the given descriptor contains more than the 

   188         maximum length of 190 characters, otherwise one of the System error codes.

   189 

   190 @capability ReadUserData

   191 */

   192 TInt RCntModel::OpenDatabase(const TDesC& aCntFile) const

   193     {

   194     TInt err = SetFileName(aCntFile);

   195     if (err == KErrNone)

   196         {

   197         TIpcArgs args;

   198         args.Set(0,&aCntFile);

   199         err = SendReceive(ECntOpenDataBase, args);

   200         }

   201 

   202     return err;

   203     }

   204 

   205 

   206 /**

   207 Open a named contact database asynchronously.

   208 

   209 Opens the default contacts database if the default argument is used.  The given

   210 descriptor must not contain more than KCntMaxFilePath characters.

   211 

   212 @param aStatus Asynchronous request object.  Request is completed when database

   213 has been opened.

   214 @param aCntFile Contacts database filename (in the form drive:database).

   215 Defaults to KCntDefaultDrive.

   216 

   217 @capability ReadUserData

   218 */

   219 void RCntModel::OpenDatabaseAsyncL(TRequestStatus& aStatus, const TDesC& aCntFile)

   220     {

   221     User::LeaveIfError(SetFileName(aCntFile));

   222 

   223     TIpcArgs args;

   224     args.Set(0,&aCntFile);

   225     SendReceive(ECntOpenDataBase, args, aStatus);

   226     }

   227 

   228 

   229 /**

   230 Cancel last asynchronous database open request.

   231 

   232 @capability None

   233 */

   234 void RCntModel::CancelAsyncOpen() 

   235 	{

   236 	SendReceive(ECntCancelAsyncOpenDatabase);		

   237 	}

   238 

   239 

   240 /**

   241 Handle a premature termination of the contact server process by re-connecting

   242 the session and re-opening the database.

   243 

   244 @capability ReadUserData

   245 */

   246 void RCntModel::HandlePrematureServerTerminationL()

   247 	{

   248 	if (iNoOfSvrStartAttempts > KMaxTimesToRestartServer)

   249 		{

   250 		User::Leave(KErrServerTerminated);

   251 		}

   252 	ConnectL();

   253 	User::LeaveIfError(OpenDatabase(iFileName));

   254 	++iNoOfSvrStartAttempts;

   255 	}

   256 

   257 	

   258 /**

   259 Set the database filename. Used to re-open the database if the server is

   260 terminated prematurely.

   261 

   262 @param aCntFile Contacts database filename (in the form drive:database).

   263 @return KErrNone if success, KErrArgument if the given descriptor contains more than the 

   264         maximum length of 190 characters.         

   265 */

   266 TInt RCntModel::SetFileName(const TDesC& aCntFile) const

   267     {

   268     if(aCntFile.Length() > KCntMaxFilePath)

   269         {

   270         return KErrArgument;

   271         }

   272 

   273     iFileName = aCntFile;

   274     return KErrNone;

   275     }

   276 

   277 

   278 /**

   279 Close currently open database.

   280 

   281 @capability None

   282 */

   283 void RCntModel::CloseDatabase() const

   284 	{

   285 	(void)SendReceive(ECntCloseDataBase);

   286 	}

   287 

   288 

   289 /**

   290 Get the machine ID. 

   291 

   292 Note: This function can leave.

   293 

   294 @return Machine ID.

   295 

   296 @leave KErrNone The send operation is successful

   297 @leave KErrServerTerminated The server no longer present

   298 @leave KErrServerBusy There are no message slots available

   299 @leave KErrNoMemory There is insufficient memory available

   300 

   301 

   302 @capability None

   303 */

   304 TInt64 RCntModel::MachineId() const

   305 	{

   306 	TIpcArgs args;

   307 	TPckgBuf<TInt64> machineID;

   308 	args.Set(0, &machineID);

   309 	User::LeaveIfError(SendReceive(ECntMachineID, args)); // this can leave

   310 	return machineID();	

   311 	}

   312 

   313 

   314 /**

   315 Set the machine ID (debug only).

   316 

   317 @param aMachineUniqueId New machine ID.

   318 

   319 @capability None

   320 */

   321 void RCntModel::OverrideMachineUniqueId(TInt64 aMachineUniqueId)

   322 	{

   323 	TIpcArgs args;

   324 	TPckgBuf<TInt64> machineID(aMachineUniqueId);

   325 	args.Set(0, &machineID);

   326 	(void)SendReceive(ECntOverrideMachineID, args);	

   327 	}

   328 

   329 

   330 /**

   331 Replace a named contact database with an empty one, replacing any database with

   332 the same name.  Replaces the default contacts database if the default argument

   333 is used.  The given descriptor must not contain more than KCntMaxFilePath

   334 characters.

   335 

   336 @param aCntFile Contacts database filename (in the form drive:database).

   337 Defaults to KCntDefaultDrive.

   338 

   339 @return KErrNone if success, KErrArgument if the given descriptor contains more than the 

   340         maximum length of 190 characters, KErrInUse if the database is currently open, 

   341         otherwise one of the System error codes.

   342 

   343 @capability WriteUserData

   344 */

   345 TInt RCntModel::ReplaceDatabase(const TDesC& aCntFile) const

   346     {

   347     TInt err = SetFileName(aCntFile);

   348     if (err == KErrNone)

   349         {

   350         TIpcArgs args;

   351         args.Set(0,&aCntFile);

   352 

   353         err = SendReceive(ECntReplaceDatabase, args);

   354         }

   355 

   356     return err;

   357     }

   358 

   359 

   360 /**

   361 Returns an array of contact item IDs for all the contact items which may contain

   362 the specified telephone number in a telephone, fax or SMS type field.

   363 

   364 @see CContactDatabase::MatchPhoneNumberL() for more details on the match.

   365 

   366 @param aNumber Phone number string

   367 @param aMatchLengthFromRight Number of digits from the right of the phone number

   368 to use.  Up to 15 digits can be specified and it is recommended that at least 7

   369 match digits are specified.

   370 

   371 @return CContactIdArray of candidate matches.

   372 

   373 @capability ReadUserData

   374 */

   375 CContactIdArray* RCntModel::MatchPhoneNumberL(const TDesC& aNumber, const TInt aMatchLengthFromRight)

   376 	{

   377 	TIpcArgs args;

   378 	args.Set(0, &iPackager->GetReceivingBufferL());

   379 	args.Set(1, MLplCollection::EMatchPhoneNos);

   380 	args.Set(2, &aNumber);

   381 	args.Set(3, aMatchLengthFromRight);

   382 	

   383 	TInt newBuffSize = 0;

   384 	User::LeaveIfError(newBuffSize = SendReceive(ECntGetCollection, args));

   385 	

   386 	if (newBuffSize > 0)

   387 		{

   388 		// If the buffer is not large enough resize the packager's internal

   389 		// buffer and make the call again.

   390 		args.Set(0, &iPackager->GetReceivingBufferL(newBuffSize));

   391 		User::LeaveIfError(newBuffSize = SendReceive(ECntGetCollection, args));		

   392 		}

   393 		

   394 	CContactIdArray* idArray = iPackager->UnpackCntIdArrayLC();	

   395 	CleanupStack::Pop(idArray);

   396 

   397 	return idArray;

   398 	}

   399 	

   400 	

   401 

   402 /**

   403 Create an empty named contact database.

   404 

   405 Creates the default contacts database if the default argument is used.  The

   406 given descriptor must not contain more than KCntMaxFilePath characters.

   407 

   408 @param aCntFile Contacts database filename (in the form drive:database).

   409 Defaults to KCntDefaultDrive.

   410 

   411 @return KErrNone if success, KErrArgument if the given descriptor contains more than the 

   412         maximum length of 190 characters, KErrAlreadyExists if the database already 

   413         exists otherwise one of the System error codes.

   414 

   415 @capability WriteUserData

   416 */

   417 TInt RCntModel::CreateDatabase(const TDesC& aCntFile) const

   418     {

   419     TInt err = SetFileName(aCntFile);

   420     if (err == KErrNone)

   421         {

   422         TIpcArgs args;

   423         args.Set(0,&aCntFile);

   424         err = SendReceive(ECntCreateDatabase, args);

   425         }

   426     return err;

   427     }

   428 

   429 

   430 /**

   431 Create the system template.

   432 

   433 @return KErrNone if success otherwise one of the System error codes.

   434 	

   435 @capability WriteUserData

   436 */

   437 TInt RCntModel::ReCreateTemplate() const

   438 	{

   439 	return SendReceive(ECntReCreateTemplate);

   440 	}

   441 

   442 

   443 /**

   444 Get the database file UID.

   445 

   446 @return Pointer to file UID.

   447 

   448 @capability None

   449 */

   450 TPtrC RCntModel::FileUidL() const

   451 	{

   452 	TIpcArgs args;

   453 	args.Set(0, &iFileUid);

   454 	User::LeaveIfError (SendReceive(ECntFileUniqueId, args));

   455     return iFileUid;

   456 	}

   457 

   458 

   459 /**

   460 Determine if the database is ready.  Ready in this context means that the

   461 database is open and readable/writable (i.e. the state machine is in

   462 CStateWritable).

   463 

   464 @capability None

   465 

   466 @return ETrue if the database is ready, EFalse if the database is not ready.

   467 */

   468 TBool RCntModel::DatabaseReadyL() const

   469     {

   470     TBool retVal = EFalse;

   471 

   472     // Although the ECntGetDatabaseReady msg. is completed with TBool values,

   473     // during message processing, it is possible that ServiceError() occurs,

   474     // causing the message to be completed with negative error codes.

   475     // LeaveIfError() would protect against such cases.

   476     User::LeaveIfError(retVal = SendReceive(ECntGetDatabaseReady));

   477 

   478     return retVal;

   479     }

   480 

   481 

   482 /**

   483 Tests whether a contact item's hint bit field matches a filter.

   484 

   485 @param aBitWiseFilter The filter to compare the item against.  This is a

   486 combination of TContactViewFilter values.

   487 @param aContactId The ID of the item in the database.

   488 

   489 @return ETrue if the item is of the correct type for inclusion in the database 

   490 and its hint bit field matches the specified filter, EFalse if either of these

   491 conditions are not met.

   492 

   493 @capability None

   494 */

   495 TBool RCntModel::ContactMatchesHintFieldL(TInt aBitWiseFilter, TContactItemId aContactId)

   496     {

   497     TIpcArgs args;

   498     args.Set(0, aBitWiseFilter);

   499     args.Set(1, aContactId);

   500     TBool retVal = EFalse;

   501 

   502     // Although the ECntMatchesHintField msg. is completed with TBool values,

   503     // during message processing, it is possible that ServiceError() occurs,

   504     // causing the message to be completed with negative error codes.

   505     // LeaveIfError() would protect against such cases.

   506     User::LeaveIfError (retVal = SendReceive(ECntMatchesHintField, args));

   507 

   508     return retVal;

   509     }

   510 

   511 

   512 /**

   513 Delete a named contact database.

   514 

   515 Deletes the default contacts database if the default argument is used.  The

   516 given descriptor must not contain more than KCntMaxFilePath characters.

   517 

   518 @param aCntFile Contacts database filename (in the form drive:database).

   519 Defaults to KCntDefaultDrive.

   520 

   521 @return KErrNone if success, KErrArgument if the given descriptor contains more 

   522         than the maximum length of 190 characters, KErrInUse if the database is 

   523         in use, KErrNotFound if the database does not exist otherwise one of the 

   524         System error codes.

   525 

   526 @capability WriteUserData

   527 */

   528 TInt RCntModel::DeleteDatabase(const TDesC& aCntFile) const

   529 	{

   530 	if(aCntFile.Length() > KCntMaxFilePath)

   531 		{

   532 		return KErrArgument;

   533 		}

   534 	TIpcArgs args;

   535 	args.Set(0,&aCntFile);

   536 	return SendReceive(ECntDeleteDatabase,args);

   537 	}

   538 

   539 

   540 /**

   541 Get the name of the default contact database file.

   542 

   543 The given descriptor must have room for minimum of KCntMaxFilePath characters.

   544 

   545 @param aCntFile Contains the default contact database name on return.

   546 

   547 @return KErrNone if success, KErrArgument if the given descriptor contains more 

   548         than the maximum length of 190 characters, otherwise one of the System 

   549         error codes.

   550 

   551 @capability None

   552 */

   553 TInt RCntModel::DefaultDatabase(TDes& aCntFile) const

   554 	{

   555 	TIpcArgs args;

   556 	args.Set(0,&aCntFile);

   557 	return SendReceive(ECntGetDefaultDatabaseName,args);

   558 	}

   559 

   560 

   561 /**

   562 Retrieve the current contact database drive.

   563 

   564 @param aDriveUnit Contains the current contact database drive unit on return.

   565 

   566 @return KErrNone if success otherwise one of the System error codes.

   567 

   568 @capability None

   569 */

   570 TInt RCntModel::DatabaseDrive(TDriveUnit& aDriveUnit) const

   571 	{

   572 	TInt ret = SendReceive(ECntDatabaseDrive);

   573 	if (ret >= KErrNone)

   574 		{

   575 		aDriveUnit = ret;	

   576 		}

   577 	return ret;

   578 	}

   579 

   580 

   581 /**

   582 Sets the contact database drive and optionally moves the default contact

   583 database from its current location to the new drive.  This function guarantees

   584 an all or nothing operation.  If the database is not successfully moved, the

   585 drive setting is not updated to reflect the change.

   586 

   587 @param aDriveUnit The drive to which to move the contact database.

   588 @param aCopy ETrue moves the existing file to the specified drive.  Deletion of

   589 the source file will fail if it is in use.  EFalse does not move the file.  The

   590 default argument value is ETrue.

   591 

   592 @return KErrNone if success, KErrInUse if destination file for copy is open,

   593 KErrNotFound found if source contact database (default) cannot be found,

   594 KErrAlreadyExists if the destination contact database file exists.

   595 

   596 @capability WriteUserData

   597 */

   598 void RCntModel::SetDatabaseDriveL(TDriveUnit aDriveUnit, TBool aCopy)

   599 	{

   600 	TIpcArgs args;

   601 	args.Set(0,aDriveUnit);

   602 	args.Set(1,aCopy);

   603 	User::LeaveIfError(SendReceive(ECntSetDatabaseDrive,args));

   604 	}

   605 

   606 /** 

   607 Gets the size of the database file in bytes.

   608 

   609 @return The size of the contact database in bytes.

   610 

   611 @capability None

   612 */

   613 TInt RCntModel::FileSize() const

   614 	{

   615 	return SendReceive(ECntFilesSize);	

   616 	}

   617 

   618 /**

   619 Determine if the named contact database file exists.

   620 

   621 If the aCntFile argument is the default, determines if default contact database

   622 file exists.

   623 

   624 @param aCntFile Contacts database filename (in the form drive:database).

   625 @leave KErrArgument if the given descriptor contains more than the maximum length 

   626        of 190 characters, otherwise one of the System error codes.

   627 @return ETrue if exists, EFalse does not exist. 

   628 @capability None

   629 */

   630 TBool RCntModel::DatabaseExistsL(const TDesC& aCntFile) const

   631     {

   632     if(aCntFile.Length() > KCntMaxFilePath)

   633         {

   634         User::Leave(KErrArgument);

   635         }

   636 

   637     TIpcArgs args;

   638     args.Set(0,&aCntFile);

   639     TBool ret = EFalse;

   640 

   641     // Although ECntDatabaseExists is normally completed with TBool values,

   642     // ServiceError() can occur which leads to a negative system error codes

   643     // being returned.  User::LeaveIfError will allow that to be properly handled.

   644     User::LeaveIfError(ret = SendReceive(ECntDatabaseExists,args));

   645 

   646     return ret;

   647     }

   648 

   649 

   650 /**

   651 List the contact database files for any given drive unit.  Lists all databases

   652 on all drives if aDriveUnit is set to NULL.

   653 

   654 @param aDriveUnit The drive unit to search.  Searches all drives if default

   655 argument is used.

   656 

   657 @return CDesCArray containing the database list.  Always returns list even if

   658 empty.

   659 

   660 @leave KErrNoMemory if not enough free memory, KErrNotReady if drive does not,

   661 otherwise one of the System error codes.

   662 

   663 @capability ReadUserData

   664 */

   665 CDesCArray* RCntModel::ListDatabasesL(TDriveUnit* aDriveUnit) const

   666 	{

   667 	// Convert the drive unit to an integer for IPC.  The TDriveUnit constructor

   668 	// does not allow values outside 0 - 25.

   669 	TInt driveNumber;

   670 	(aDriveUnit == NULL) ? (driveNumber = ECntAllDrives) : (driveNumber = *aDriveUnit);

   671 

   672 	// Provide a CBufFlat for receiving the list of databases from the server.

   673 	// Format is a (proprietary) serialized CDesCArray.

   674 	const TInt KInitialBufferSize = 200;

   675 	CBufFlat* listBuffer = CBufFlat::NewL(KInitialBufferSize);

   676 	CleanupStack::PushL(listBuffer);

   677 	listBuffer->ExpandL(0,KInitialBufferSize);

   678 

   679 	// IPC argument list is:

   680 	// 0 (Return param)	- Address of our receive buffer

   681 	// 1 (Param)		- The drive number 0 - 25 or ECntAllDrives

   682 	// 2 (Return param)	- The size of buffer required for the transfer

   683 	TIpcArgs args;

   684 	TPtr8 ptr(listBuffer->Ptr(0));

   685 	args.Set(0,&ptr);

   686 	args.Set(1,driveNumber);

   687 	TPckgBuf<TInt> size;

   688 	args.Set(2,&size);

   689 	User::LeaveIfError(SendReceive(ECntListDatabases,args));

   690 

   691 	// Check if our buffer was large enough by reading returned size argument.

   692 	// The server will not have written any data if our povided buffer was not

   693 	// big enough.

   694 	if(size() > KInitialBufferSize)

   695 		{

   696 		// Not big enough but now we know how big the buffer needs to be.

   697 		// Just allocate buffer again, reset the IPC args and call again.

   698 		CleanupStack::PopAndDestroy(listBuffer);

   699 		listBuffer = CBufFlat::NewL(size());

   700 		CleanupStack::PushL(listBuffer);

   701 		listBuffer->ExpandL(0,size());

   702 		ptr.Set(listBuffer->Ptr(0));

   703 		args.Set(0,&ptr);

   704 		args.Set(1,driveNumber);

   705 		args.Set(2,&size);

   706 		User::LeaveIfError(SendReceive(ECntListDatabases,args));

   707 		}

   708 

   709 	// Wrap the buffer in a read stream class to internalize.

   710 	RBufReadStream readStream;

   711 	readStream.Open(*listBuffer);

   712 	CleanupClosePushL(readStream);

   713 

   714 	// Number of array elements.

   715 	const TInt count = readStream.ReadUint32L();

   716 	// Use count if it is not zero.

   717 	CDesCArray* list = new(ELeave) CDesCArrayFlat(count ? count : 1);

   718 	CleanupStack::PushL(list);

   719 	for (TInt i=0; i<count; ++i)

   720 		{

   721 		TFileName path;

   722 		TInt length=readStream.ReadInt8L();

   723 		readStream.ReadL(path,length);

   724 		// Add to the list.

   725 		list->AppendL(path);

   726 		}

   727 

   728 	CleanupStack::Pop(list);

   729 	CleanupStack::PopAndDestroy(&readStream);

   730 	CleanupStack::PopAndDestroy(listBuffer);

   731 	

   732 	return list;

   733 	}

   734 

   735 

   736 /**

   737 Add a new contact to the database.

   738 

   739 @param aContact The contact to be added to the database.

   740 

   741 @capability WriteUserData

   742 */

   743 TContactItemId RCntModel::CreateContactL(CContactItem& aContact) const

   744 	{

   745 	// Pack the contact into the first IPC argument.

   746 	TIpcArgs args;

   747 	TPtr8 ptr(iPackager->PackL(aContact));

   748 	args.Set(0,&ptr);

   749 

   750 	TInt cntId = 0;

   751 	User::LeaveIfError(cntId = SendReceive(ECntItemCreate, args));

   752 

   753 	return cntId;

   754 	}

   755 

   756 

   757 /**

   758 Delete a contact from the database.

   759 

   760 @param aContact The contact to be deleted.

   761 @param aCntEventType The event type to pass on to the observers.

   762 @param aDecAccessCount If ETrue access count should be decremented prior to the

   763 deletion.

   764 

   765 @capability WriteUserData

   766 */

   767 void RCntModel::DeleteContactL(TContactItemId aCntId, TCntSendEventAction aCntEventType, TBool aDecAccessCount) const

   768 	{

   769 	TIpcArgs args(aCntId, aCntEventType, aDecAccessCount);

   770 	User::LeaveIfError(SendReceive(ECntItemDelete, args));

   771 	}

   772 

   773 /** 

   774 Open the database tables.

   775 

   776 @capability ReadUserData

   777 */

   778 void RCntModel::OpenTablesL()

   779 	{

   780 	User::LeaveIfError(SendReceive(ECntReOpenDbTables));

   781 	}

   782 

   783 

   784 /**

   785 Close the database tables.

   786 

   787 @capability None

   788 */

   789 void RCntModel::CloseTablesL()

   790 	{

   791 	User::LeaveIfError(SendReceive(ECntCloseDbTables));

   792 	}

   793 

   794 

   795 /**

   796 Update and unlock an existing contact in the database.

   797 

   798 @param aContact The contact to be updated and unlocked

   799 @param aSendChangedEvent If ETrue the changed event should be sent after the

   800 update/unlock.

   801 

   802 @capability WriteUserData

   803 */

   804 void RCntModel::CommitContactL(const CContactItem& aContact, TBool aSendChangedEvent) const

   805 	{

   806 	// Pack the contact into the first IPC argument.

   807 	TIpcArgs args; 

   808 	TPtr8 ptr(iPackager->PackL((const_cast<CContactItem&>(aContact))));

   809 	args.Set(0,&ptr);

   810 	

   811 	args.Set(1,aSendChangedEvent);

   812 

   813 	User::LeaveIfError(SendReceive(ECntItemCommit, args));

   814 	}

   815 

   816 

   817 /**

   818 Unpacks a contact item contained within the Packager's internal buffer and

   819 creates a contact item object.  Within the server, the contact item has been

   820 written to the Packager's internal buffer by the RMessage2.

   821 

   822 If the buffer size was returned then the buffer was not large enough to hold a

   823 serialised contact item.  The buffer must be expanded to the size returned by

   824 the server (ie aBufferSize) and the read operation performed again. 

   825 

   826 @see CCntPackager::SetBufferFromMessageL()

   827 	

   828 @param aBufferSize The new buffer size.

   829 @param aArgs The argument buffer where the serialised contact item is written by

   830 the server.

   831 

   832 @return CContactItem unpacked from Packager's internal buffer.

   833 

   834 @capability ReadUserData

   835 */

   836 CContactItem* RCntModel::UnPackContactLC(TInt aBufferSize, TIpcArgs& aArgs) const

   837 	{

   838 	if(aBufferSize > 0) // Packager's internal buffer is not large enough.

   839 		{

   840 		// Set new extended receiving buffer.

   841 		aArgs.Set(1, &iPackager->GetReceivingBufferL(aBufferSize));

   842 		// Perform read operation again.

   843 		User::LeaveIfError(SendReceive(ECntItemRead, aArgs));

   844 		}

   845 	return iPackager->UnpackCntItemLC();

   846 	}

   847 

   848 

   849 /**

   850 Read an existing contact in the database.

   851 

   852 @param aCntItemVDef The view definition to use.

   853 @param aCntId Contact ID to read.

   854 

   855 @return CContactItem object with contact ID aCntId.

   856 */

   857 CContactItem* RCntModel::ReadContactL(const CContactItemViewDef* aCntItemVDef, TContactItemId aCntId) const

   858 	{

   859 	TIpcArgs args;

   860 

   861 	if (aCntItemVDef) 

   862 		{

   863 		iPackager->PackL(*(const_cast<CContactItemViewDef*>(aCntItemVDef)));

   864 		// Indicates that a user ContactItemViewDef is present in first IPC

   865 		// argument.

   866 		args.Set(3,TRUE);

   867 		}

   868 	else

   869 		{

   870 		iPackager->Clear();

   871 		// Indicates that no user ContactItemViewDef is present in first IPC

   872 		// argument.  The default view definition will be used instead.

   873 		args.Set(3,FALSE);

   874 		}

   875 

   876 	args.Set(0, &iPackager->GetTransmittingBuffer());

   877 	args.Set(1, &iPackager->GetReceivingBufferL());

   878 	args.Set(2, aCntId);

   879 

   880 	TInt newBuffSize = 0;

   881 	User::LeaveIfError(newBuffSize = SendReceive(ECntItemRead, args));

   882 	CContactItem* cntItem = UnPackContactLC(newBuffSize, args);

   883 	CleanupStack::Pop(cntItem);

   884 

   885 	return cntItem;

   886 	}

   887 	

   888 	

   889 /**

   890 Open and lock an existing contact in the database.  The contact item lock is

   891 pushed onto the cleanup stack.

   892 

   893 @param aCntItemVDef The view definition to use.

   894 @param aCntId Contact ID to read.

   895 

   896 @return Opened/locked CContactItem object.

   897 */

   898 CContactItem* RCntModel::OpenContactLX(const CContactItemViewDef* aCntItemVDef, TContactItemId aCntId) const

   899 	{

   900 	TIpcArgs args;

   901 	if (aCntItemVDef) 

   902 		{

   903 		iPackager->PackL(*(const_cast<CContactItemViewDef*>(aCntItemVDef)));

   904 		// Indicates that a user ContactItemViewDef is present in first IPC

   905 		// argument.

   906 		args.Set(3,TRUE);

   907 		}

   908 	else

   909 		{

   910 		iPackager->Clear();

   911 		// Indicates that no user ContactItemViewDef is present in first IPC

   912 		// argument.  The default view definition will be used instead.

   913 		args.Set(3,FALSE);

   914 		}

   915 

   916 	args.Set(0, &iPackager->GetTransmittingBuffer());

   917 	args.Set(1, &iPackager->GetReceivingBufferL());

   918 	args.Set(2, aCntId);

   919 

   920 	TInt newBuffSize = 0;

   921 	User::LeaveIfError(newBuffSize = SendReceive(ECntItemOpen, args));

   922 

   923 	// Push the contact item lock onto the cleanup stack.  If UnPackContactLC()

   924 	// (or any other RCntModel method leaves after this point) then the last

   925 	// contact to be locked will be unlocked (aka closed).  The method returns

   926 	// with the lock remaining on the cleanup stack.

   927 	PushUnlockL(); 

   928 

   929 	CContactItem* cntItem = UnPackContactLC(newBuffSize, args);

   930 

   931 	CleanupStack::Pop(cntItem);

   932 

   933 	return cntItem;		

   934 	}

   935 

   936 

   937 /**

   938 Close/unLock an existing contact in the database.

   939 

   940 @param aCntId The contact ID of the contact to close.

   941 

   942 @return ETrue if the contact was opened before and closed after the call,

   943 EFalse if there was no need to close the contact.

   944 */

   945 TBool RCntModel::CloseContact(TContactItemId aCntId)

   946 	{

   947 	TInt res = SendReceive(ECntItemClose, TIpcArgs(aCntId));

   948 	if (res == KErrNone)

   949 		{

   950 		return ETrue;

   951 		}

   952 	return EFalse;

   953 	}

   954 

   955 

   956 /**

   957 Start a database transaction.

   958 */

   959 TInt RCntModel::BeginDbTransaction() const

   960 	{

   961 	return SendReceive(EBeginDbTransaction);

   962 	}

   963 

   964 	

   965 /**

   966 Commit a database transaction.

   967 */

   968 TInt RCntModel::CommitDbTransaction() const

   969 	{

   970 	return SendReceive(EEndDbTransaction);

   971 	}

   972 

   973 	

   974 /**

   975 Rollback a database transaction.

   976 */

   977 TInt RCntModel::RollbackDbTransaction() const

   978 	{

   979 	return SendReceive(ERollbackDbTransaction);

   980 	}

   981 

   982 

   983 /**

   984 Set the operation timeout value.  This value is the length of time that a

   985 deferred request will remain in the request queue in the State Machine before

   986 being completed with an error code.

   987 

   988 @param aMicroSeconds The operation timeout in microseconds.  This timeout will

   989 only be applied to requests sent by clients of this database after this point in

   990 time. 

   991 */

   992 void RCntModel::SetOperationTimeOutL(const TInt aMicroSeconds) const

   993 	{

   994 	TIpcArgs args;

   995 	args.Set(0, aMicroSeconds);

   996 	User::LeaveIfError(SendReceive(ECntOpsTimeOut, args));		

   997 	}

   998 

   999 	

  1000 /**

  1001 Change the existing contact view definition on the server.

  1002 

  1003 @param aView The new contact view defintion.

  1004 */

  1005 void RCntModel::SetViewDefinitionL(const CContactViewDef& aView)

  1006 	{

  1007 	TPtr8 ptr(iPackager->PackL(aView));

  1008 	User::LeaveIfError(SendReceive(ECntChangeViewDef, TIpcArgs(&ptr)));	

  1009 	}

  1010 

  1011 

  1012 /**

  1013 Add a database event observer.

  1014 

  1015 @param aObserver Observer callback inteface used to send database event.

  1016 */

  1017 void RCntModel::AddObserverL(MContactDbObserver& aObserver)

  1018 	{

  1019 	// If this is the first observer to be added then required to create the

  1020 	// database event notification monitor (lazy initialisation).

  1021 	if (!iDbNotifyMonitor)

  1022 		{

  1023 		iDbNotifyMonitor = CCntDbNotifyMonitor::NewL(*this);

  1024 		}

  1025 	iDbNotifyMonitor->AddObserverL(aObserver);

  1026 	}

  1027 

  1028 	

  1029 /**

  1030 Remove a database event observer.

  1031 

  1032 @param aObserver Observer callback inteface to be removed.

  1033 */

  1034 void RCntModel::RemoveObserver(const MContactDbObserver& aObserver)

  1035 	{

  1036 	if (iDbNotifyMonitor)

  1037 		{

  1038 		iDbNotifyMonitor->RemoveObserver(aObserver);

  1039 		// If this is the last observer to be removed then dispose of the

  1040 		// database event notification monitor (no longer required).

  1041 		if (iDbNotifyMonitor->NumberOfListeners() == 0)

  1042 			{

  1043 			delete iDbNotifyMonitor;

  1044 			iDbNotifyMonitor = NULL;

  1045 			}

  1046 		}

  1047 	}

  1048 

  1049 

  1050 /**

  1051 Request a database event from the server.

  1052 

  1053 @param aStatus Completed when database event is available.

  1054 @param aEvent When aStatus is completed contains the database event.

  1055 */

  1056 void RCntModel::StartNotificationTransfer(TRequestStatus& aStatus, TDes8& aEvent)

  1057 	{	

  1058 	SendReceive(ECntRequestEvent, TIpcArgs(&aEvent), aStatus);	

  1059 	}

  1060 

  1061 

  1062 /**

  1063 End (cancel) request for database event from server.

  1064 */

  1065 void RCntModel::EndNotificationTransfer()

  1066 	{	

  1067 	SendReceive(ECntCancelEventRequest);	

  1068 	}

  1069 	

  1070 /** 

  1071 Sets the ID of the current item and persists it in the database.  The current 

  1072 item is provided for use by clients who want to identify one contact item in the

  1073 database as the currently selected item.

  1074 

  1075 @param aContactId The ID of the current item. 

  1076 

  1077 @capability WriteUserData

  1078 */

  1079 void RCntModel::SetCurrentItem(TContactItemId aContactId) const

  1080 	{

  1081 	TIpcArgs args(aContactId);

  1082 	(void)SendReceive(ECntSetCurrentItem, args);	

  1083 	}

  1084 

  1085 	

  1086 /** 

  1087 Gets the ID of the current item, as set by SetCurrentItem().  The current item 

  1088 ID is initialised to KNullContactId when the database is opened.

  1089 

  1090 @return The ID of the current item. 

  1091 

  1092 @capability None

  1093 */

  1094 TContactItemId RCntModel::CurrentItem() const

  1095 	{		

  1096 	 TContactItemId id = SendReceive(ECntGetCurrentItem);

  1097 	 if (id < 0)

  1098 	 	{

  1099 		return KNullContactId;

  1100 		}

  1101 	 else

  1102 	 	{

  1103 		return id;

  1104 		}

  1105 	}

  1106 

  1107 

  1108 /** 

  1109 When there are multiple contact databases on a device this method can be used to

  1110 enquire which database is the current one.

  1111 

  1112 The current database functions are provided as part of current item

  1113 functionality.  In order to pass a current item from one contacts model client

  1114 to another, the receiving client needs to be using the same database.

  1115 

  1116 The current database is a path and filename, set using SetCurrentDatabase(),

  1117 which is persisted by the contacts server.

  1118 

  1119 @deprecated

  1120 

  1121 @param aDatabase The path and filename of the current database.  KNullDesC 

  1122 if no current database has been set.

  1123 

  1124 @return KErrNone if success otherwise one of the System error codes. 

  1125 

  1126 @capability None

  1127 */

  1128 TInt RCntModel::GetCurrentDatabase(TDes& aDatabase) const

  1129 	{

  1130 	TIpcArgs args(&aDatabase);

  1131 	return SendReceive(ECntGetCurrentDb, args);

  1132 	}

  1133 

  1134 

  1135 /**