1 /*

     2 * Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 /**

    20  @file

    21  @internalComponent

    22  @released

    23 */

    24 

    25 #include <s32mem.h>

    26 #include <cntitem.h>

    27 #include <cntdb.h>

    28 #include <cntfilt.h>

    29 

    30 #include "rcntmodel.h"

    31 #include "persistencelayer.h" // for mlplcollection.

    32 #include "ccntnotificationmonitor.h"

    33 #include "ccontactprivate.h" // for mprogresseventhander.

    34 #include "ccntpackager.h"

    35 #include <cntviewstore.h>

    36 

    37 

    38 /** Contacts server version number. */ 

    39 const TInt KCntServerMajorVersionNumber=1;

    40 const TInt KCntServerMinorVersionNumber=1;

    41 const TInt KCntServerBuildVersionNumber=1;

    42 

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

    44 const TInt KMaxTimesToRestartServer = 3;

    45 

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

    47 const TInt KAsyncMessageSlots=6;

    48 

    49 

    50 /**

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

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

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

    54 

    55 @capability None

    56 */

    57 void CleanupUnlockRecord(TAny *aSession)

    58 	{

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

    60 	}

    61 

    62 

    63 /**

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

    65 

    66 @capability None

    67 */

    68 void RCntModel::UnlockLastLockedContact()

    69 	{

    70 	CloseContact(KNullContactId);

    71 	}

    72 

    73 

    74 /**

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

    76 */

    77 void RCntModel::PushUnlockL() const

    78 	{

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

    80 	}

    81 

    82 

    83 /**

    84 RCntModel constructor.

    85 

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

    87 RCntModel does not derive from CBase.

    88 */

    89 RCntModel::RCntModel()

    90 	:

    91 	iDbNotifyMonitor(NULL), 

    92 	iPackager(NULL),

    93 	iConnectionId(0),

    94 	iNoOfSvrStartAttempts(0)

    95 	{

    96 	}

    97 

    98 

    99 /**

   100 Get the Contacts server version number.

   101 

   102 @return Contacts server version number.

   103 */

   104 TVersion RCntModel::Version() const

   105 	{

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

   107 	}

   108 

   109 

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

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

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

   113 _LIT(KCntServerName,"CNTSRV");

   114 

   115 

   116 /**

   117 Open a Contacts server session.

   118 */

   119 void RCntModel::ConnectL()

   120 	{

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

   122 	// with a maximum of KAsyncMessageSlots message slots.

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

   124 	

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

   126 		{

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

   128 		RProcess server;

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

   130 		

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

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

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

   134 		//view was done.

   135 		server.SetPriority(EPriorityForeground);

   136 		

   137 		// Synchronise with the server.

   138 		TRequestStatus reqStatus;

   139 		server.Rendezvous(reqStatus);

   140 		server.Resume();

   141 		

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

   143 		User::WaitForRequest(reqStatus);

   144 		server.Close();

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

   146 		

   147 		// Create the server session.

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

   149 		}

   150 	else

   151 		{

   152 		User::LeaveIfError(err);

   153 		}

   154 

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

   156 	if (iPackager == NULL)	

   157 		{

   158 		iPackager = CCntPackager::NewL();

   159 		}

   160 	

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

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

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

   164 	ConnectionId();

   165 	}

   166 

   167 	

   168 /**

   169 Close session.

   170 */

   171 void RCntModel::Close()

   172 	{

   173 	delete iPackager;

   174 	iPackager = NULL;

   175 	delete iDbNotifyMonitor;

   176 	iDbNotifyMonitor = NULL;

   177 	RHandleBase::Close();

   178 	}

   179 

   180 

   181 /**

   182 Open a named contact database.

   183 

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

   185 descriptor must not contain more than KCntMaxFilePath characters.

   186 

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

   188 KCntDefaultDrive.

   189 

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

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

   192 

   193 @capability ReadUserData

   194 */

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

   196     {

   197     TInt err = SetFileName(aCntFile);

   198     if (err == KErrNone)

   199         {

   200         TIpcArgs args;

   201         args.Set(0,&aCntFile);

   202         err = SendReceive(ECntOpenDataBase, args);

   203         }

   204 

   205     return err;

   206     }

   207 

   208 

   209 /**

   210 Open a named contact database asynchronously.

   211 

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

   213 descriptor must not contain more than KCntMaxFilePath characters.

   214 

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

   216 has been opened.

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

   218 Defaults to KCntDefaultDrive.

   219 

   220 @capability ReadUserData

   221 */

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

   223     {

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

   225 

   226     TIpcArgs args;

   227     args.Set(0,&aCntFile);

   228     SendReceive(ECntOpenDataBase, args, aStatus);

   229     }

   230 

   231 

   232 /**

   233 Cancel last asynchronous database open request.

   234 

   235 @capability None

   236 */

   237 void RCntModel::CancelAsyncOpen() 

   238 	{

   239 	SendReceive(ECntCancelAsyncOpenDatabase);		

   240 	}

   241 

   242 

   243 /**

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

   245 the session and re-opening the database.

   246 

   247 @capability ReadUserData

   248 */

   249 void RCntModel::HandlePrematureServerTerminationL()

   250 	{

   251 	if (iNoOfSvrStartAttempts > KMaxTimesToRestartServer)

   252 		{

   253 		User::Leave(KErrServerTerminated);

   254 		}

   255 	ConnectL();

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

   257 	++iNoOfSvrStartAttempts;

   258 	}

   259 

   260 	

   261 /**

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

   263 terminated prematurely.

   264 

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

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

   267         maximum length of 190 characters.         

   268 */

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

   270     {

   271     if(aCntFile.Length() > KCntMaxFilePath)

   272         {

   273         return KErrArgument;

   274         }

   275 

   276     iFileName = aCntFile;

   277     return KErrNone;

   278     }

   279 

   280 

   281 /**

   282 Close currently open database.

   283 

   284 @capability None

   285 */

   286 void RCntModel::CloseDatabase() const

   287 	{

   288 	(void)SendReceive(ECntCloseDataBase);

   289 	}

   290 

   291 

   292 /**

   293 Get the machine ID. 

   294 

   295 Note: This function can leave.

   296 

   297 @return Machine ID.

   298 

   299 @leave KErrNone The send operation is successful

   300 @leave KErrServerTerminated The server no longer present

   301 @leave KErrServerBusy There are no message slots available

   302 @leave KErrNoMemory There is insufficient memory available

   303 

   304 

   305 @capability None

   306 */

   307 TInt64 RCntModel::MachineId() const

   308 	{

   309 	TIpcArgs args;

   310 	TPckgBuf<TInt64> machineID;

   311 	args.Set(0, &machineID);

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

   313 	return machineID();	

   314 	}

   315 

   316 

   317 /**

   318 Set the machine ID (debug only).

   319 

   320 @param aMachineUniqueId New machine ID.

   321 

   322 @capability None

   323 */

   324 void RCntModel::OverrideMachineUniqueId(TInt64 aMachineUniqueId)

   325 	{

   326 	TIpcArgs args;

   327 	TPckgBuf<TInt64> machineID(aMachineUniqueId);

   328 	args.Set(0, &machineID);

   329 	(void)SendReceive(ECntOverrideMachineID, args);	

   330 	}

   331 

   332 

   333 /**

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

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

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

   337 characters.

   338 

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

   340 Defaults to KCntDefaultDrive.

   341 

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

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

   344         otherwise one of the System error codes.

   345 

   346 @capability WriteUserData

   347 */

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

   349     {

   350     TInt err = SetFileName(aCntFile);

   351     if (err == KErrNone)

   352         {

   353         TIpcArgs args;

   354         args.Set(0,&aCntFile);

   355 

   356         err = SendReceive(ECntReplaceDatabase, args);

   357         }

   358 

   359     return err;

   360     }

   361 

   362 

   363 /**

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

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

   366 

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

   368 

   369 @param aNumber Phone number string

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

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

   372 match digits are specified.

   373 

   374 @return CContactIdArray of candidate matches.

   375 

   376 @capability ReadUserData

   377 */

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

   379 	{

   380 	TIpcArgs args;

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

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

   383 	args.Set(2, &aNumber);

   384 	args.Set(3, aMatchLengthFromRight);

   385 	

   386 	TInt newBuffSize = 0;

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

   388 	

   389 	if (newBuffSize > 0)

   390 		{

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

   392 		// buffer and make the call again.

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

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

   395 		}

   396 		

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

   398 	CleanupStack::Pop(idArray);

   399 

   400 	return idArray;

   401 	}

   402 	

   403 	

   404 

   405 /**

   406 Create an empty named contact database.

   407 

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

   409 given descriptor must not contain more than KCntMaxFilePath characters.

   410 

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

   412 Defaults to KCntDefaultDrive.

   413 

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

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

   416         exists otherwise one of the System error codes.

   417 

   418 @capability WriteUserData

   419 */

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

   421     {

   422     TInt err = SetFileName(aCntFile);

   423     if (err == KErrNone)

   424         {

   425         TIpcArgs args;

   426         args.Set(0,&aCntFile);

   427         err = SendReceive(ECntCreateDatabase, args);

   428         }

   429     return err;

   430     }

   431 

   432 

   433 /**

   434 Create the system template.

   435 

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

   437 	

   438 @capability WriteUserData

   439 */

   440 TInt RCntModel::ReCreateTemplate() const

   441 	{

   442 	return SendReceive(ECntReCreateTemplate);

   443 	}

   444 

   445 

   446 /**

   447 Get the database file UID.

   448 

   449 @return Pointer to file UID.

   450 

   451 @capability None

   452 */

   453 TPtrC RCntModel::FileUidL() const

   454 	{

   455 	TIpcArgs args;

   456 	args.Set(0, &iFileUid);

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

   458     return iFileUid;

   459 	}

   460 

   461 

   462 /**

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

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

   465 CStateWritable).

   466 

   467 @capability None

   468 

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

   470 */

   471 TBool RCntModel::DatabaseReadyL() const

   472     {

   473     TBool retVal = EFalse;

   474 

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

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

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

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

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

   480 

   481     return retVal;

   482     }

   483 

   484 

   485 /**

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

   487 

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

   489 combination of TContactViewFilter values.

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

   491 

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

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

   494 conditions are not met.

   495 

   496 @capability None

   497 */

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

   499     {

   500     TIpcArgs args;

   501     args.Set(0, aBitWiseFilter);

   502     args.Set(1, aContactId);

   503     TBool retVal = EFalse;

   504 

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

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

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

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

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

   510 

   511     return retVal;

   512     }

   513 

   514 

   515 /**

   516 Delete a named contact database.

   517 

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

   519 given descriptor must not contain more than KCntMaxFilePath characters.

   520 

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

   522 Defaults to KCntDefaultDrive.

   523 

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

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

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

   527         System error codes.

   528 

   529 @capability WriteUserData

   530 */

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

   532 	{

   533 	if(aCntFile.Length() > KCntMaxFilePath)

   534 		{

   535 		return KErrArgument;

   536 		}

   537 	TIpcArgs args;

   538 	args.Set(0,&aCntFile);

   539 	return SendReceive(ECntDeleteDatabase,args);

   540 	}

   541 

   542 

   543 /**

   544 Get the name of the default contact database file.

   545 

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

   547 

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

   549 

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

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

   552         error codes.

   553 

   554 @capability None

   555 */

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

   557 	{

   558 	TIpcArgs args;

   559 	args.Set(0,&aCntFile);

   560 	return SendReceive(ECntGetDefaultDatabaseName,args);

   561 	}

   562 

   563 

   564 /**

   565 Retrieve the current contact database drive.

   566 

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

   568 

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

   570 

   571 @capability None

   572 */

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

   574 	{

   575 	TInt ret = SendReceive(ECntDatabaseDrive);

   576 	if (ret >= KErrNone)

   577 		{

   578 		aDriveUnit = ret;	

   579 		}

   580 	return ret;

   581 	}

   582 

   583 

   584 /**

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

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

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

   588 drive setting is not updated to reflect the change.

   589 

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

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

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

   593 default argument value is ETrue.

   594 

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

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

   597 KErrAlreadyExists if the destination contact database file exists.

   598 

   599 @capability WriteUserData

   600 */

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

   602 	{

   603 	TIpcArgs args;

   604 	args.Set(0,aDriveUnit);

   605 	args.Set(1,aCopy);

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

   607 	}

   608 

   609 /** 

   610 Gets the size of the database file in bytes.

   611 

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

   613 

   614 @capability None

   615 */

   616 TInt RCntModel::FileSize() const

   617 	{

   618 	return SendReceive(ECntFilesSize);	

   619 	}

   620 

   621 /**

   622 Determine if the named contact database file exists.

   623 

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

   625 file exists.

   626 

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

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

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

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

   631 @capability None

   632 */

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

   634     {

   635     if(aCntFile.Length() > KCntMaxFilePath)

   636         {

   637         User::Leave(KErrArgument);

   638         }

   639 

   640     TIpcArgs args;

   641     args.Set(0,&aCntFile);

   642     TBool ret = EFalse;

   643 

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

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

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

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

   648 

   649     return ret;

   650     }

   651 

   652 

   653 /**

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

   655 on all drives if aDriveUnit is set to NULL.

   656 

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

   658 argument is used.

   659 

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

   661 empty.

   662 

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

   664 otherwise one of the System error codes.

   665 

   666 @capability ReadUserData

   667 */

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

   669 	{

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

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

   672 	TInt driveNumber;

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

   674 

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

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

   677 	const TInt KInitialBufferSize = 200;

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

   679 	CleanupStack::PushL(listBuffer);

   680 	listBuffer->ExpandL(0,KInitialBufferSize);

   681 

   682 	// IPC argument list is:

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

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

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

   686 	TIpcArgs args;

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

   688 	args.Set(0,&ptr);

   689 	args.Set(1,driveNumber);

   690 	TPckgBuf<TInt> size;

   691 	args.Set(2,&size);

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

   693 

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

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

   696 	// big enough.

   697 	if(size() > KInitialBufferSize)

   698 		{

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

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

   701 		CleanupStack::PopAndDestroy(listBuffer);

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

   703 		CleanupStack::PushL(listBuffer);

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

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

   706 		args.Set(0,&ptr);

   707 		args.Set(1,driveNumber);

   708 		args.Set(2,&size);

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

   710 		}

   711 

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

   713 	RBufReadStream readStream;

   714 	readStream.Open(*listBuffer);

   715 	CleanupClosePushL(readStream);

   716 

   717 	// Number of array elements.

   718 	const TInt count = readStream.ReadUint32L();

   719 	// Use count if it is not zero.

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

   721 	CleanupStack::PushL(list);

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

   723 		{

   724 		TFileName path;

   725 		TInt length=readStream.ReadInt8L();

   726 		readStream.ReadL(path,length);

   727 		// Add to the list.

   728 		list->AppendL(path);

   729 		}

   730 

   731 	CleanupStack::Pop(list);

   732 	CleanupStack::PopAndDestroy(&readStream);

   733 	CleanupStack::PopAndDestroy(listBuffer);

   734 	

   735 	return list;

   736 	}

   737 

   738 

   739 /**

   740 Add a new contact to the database.

   741 

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

   743 

   744 @capability WriteUserData

   745 */

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

   747 	{

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

   749 	TIpcArgs args;

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

   751 	args.Set(0,&ptr);

   752 

   753 	TInt cntId = 0;

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

   755 

   756 	return cntId;

   757 	}

   758 

   759 

   760 /**

   761 Delete a contact from the database.

   762 

   763 @param aContact The contact to be deleted.

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

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

   766 deletion.

   767 

   768 @capability WriteUserData

   769 */

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

   771 	{

   772 	TIpcArgs args(aCntId, aCntEventType, aDecAccessCount);

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

   774 	}

   775 

   776 /** 

   777 Open the database tables.

   778 

   779 @capability ReadUserData

   780 */

   781 void RCntModel::OpenTablesL()

   782 	{

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

   784 	}

   785 

   786 

   787 /**

   788 Close the database tables.

   789 

   790 @capability None

   791 */

   792 void RCntModel::CloseTablesL()

   793 	{

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

   795 	}

   796 

   797 

   798 /**

   799 Update and unlock an existing contact in the database.

   800 

   801 @param aContact The contact to be updated and unlocked

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

   803 update/unlock.

   804 

   805 @capability WriteUserData

   806 */

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

   808 	{

   809     //check what contacts were added/removed to a group

   810     if (aContact.Type() == KUidContactGroup)

   811         {

   812         const CContactGroup& group = static_cast<const CContactGroup&>(aContact);

   813         if (group.iInitialContactIds != NULL)

   814             {

   815             group.iAddedContactIds = CContactIdArray::NewL();

   816             group.iRemovedContactIds = CContactIdArray::NewL();

   817             for (int i = 0; i < group.iItems->Count(); i++)

   818                 {

   819                 if (group.iInitialContactIds->Find(group.iItems->operator[](i)) == KErrNotFound)

   820                     {

   821                     group.iAddedContactIds->AddL(group.iItems->operator[](i));

   822                     }

   823                 }

   824             for (int j = 0; j < group.iInitialContactIds->Count(); j++)

   825                 {

   826                 if (group.iItems->Find(group.iInitialContactIds->operator[](j)) == KErrNotFound)

   827                     {

   828                     group.iRemovedContactIds->AddL(group.iInitialContactIds->operator[](j));

   829                     }

   830                 }           

   831             }

   832         }	

   833 	

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

   835 	TIpcArgs args; 

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

   837 	args.Set(0,&ptr);

   838 	

   839 	args.Set(1,aSendChangedEvent);

   840 

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

   842 	

   843     //clear list of contacts added/removed to a group

   844     if (aContact.Type() == KUidContactGroup)

   845         {

   846         const CContactGroup& group = static_cast<const CContactGroup&>(aContact);

   847         if (group.iAddedContactIds != NULL)

   848             {

   849             delete group.iAddedContactIds;

   850             group.iAddedContactIds = NULL;

   851             }

   852         if (group.iRemovedContactIds != NULL)

   853             {

   854             delete group.iRemovedContactIds;

   855             group.iRemovedContactIds = NULL;

   856             }

   857         if (group.iInitialContactIds != NULL)

   858             {

   859             delete group.iInitialContactIds;

   860             group.iInitialContactIds = NULL;

   861             }

   862         }	

   863 	}

   864 

   865 

   866 /**

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

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

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

   870 

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

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

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

   874 

   875 @see CCntPackager::SetBufferFromMessageL()

   876 	

   877 @param aBufferSize The new buffer size.

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

   879 the server.

   880 

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

   882 

   883 @capability ReadUserData

   884 */

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

   886 	{

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

   888 		{

   889 		// Set new extended receiving buffer.

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

   891 		// Perform read operation again.

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

   893 		}

   894 	return iPackager->UnpackCntItemLC();

   895 	}

   896 

   897 

   898 /**

   899 Read an existing contact in the database.

   900 

   901 @param aCntItemVDef The view definition to use.

   902 @param aCntId Contact ID to read.

   903 

   904 @return CContactItem object with contact ID aCntId.

   905 */

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

   907 	{

   908 	TIpcArgs args;

   909 

   910 	if (aCntItemVDef) 

   911 		{

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

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

   914 		// argument.

   915 		args.Set(3,TRUE);

   916 		}

   917 	else

   918 		{

   919 		iPackager->Clear();

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

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

   922 		args.Set(3,FALSE);

   923 		}

   924 

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

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

   927 	args.Set(2, aCntId);

   928 

   929 	TInt newBuffSize = 0;

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

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

   932 	CleanupStack::Pop(cntItem);

   933 

   934 	return cntItem;

   935 	}

   936 	

   937 	

   938 /**

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

   940 pushed onto the cleanup stack.

   941 

   942 @param aCntItemVDef The view definition to use.

   943 @param aCntId Contact ID to read.

   944 

   945 @return Opened/locked CContactItem object.

   946 */

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

   948 	{

   949 	TIpcArgs args;

   950 	if (aCntItemVDef) 

   951 		{

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

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

   954 		// argument.

   955 		args.Set(3,TRUE);

   956 		}

   957 	else

   958 		{

   959 		iPackager->Clear();

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

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

   962 		args.Set(3,FALSE);

   963 		}

   964 

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

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

   967 	args.Set(2, aCntId);

   968 

   969 	TInt newBuffSize = 0;

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

   971 

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

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

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

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

   976 	PushUnlockL(); 

   977 

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

   979 	

   980     //save a list of contacts belonging to a group

   981     if (cntItem->Type() == KUidContactGroup)

   982         {

   983         CContactGroup* group = static_cast<CContactGroup*>(cntItem);

   984         delete group->iInitialContactIds;

   985         group->iInitialContactIds = NULL;

   986         group->iInitialContactIds = CContactIdArray::NewL(group->ItemsContained());

   987         }	

   988 	

   989 	CleanupStack::Pop(cntItem);

   990 	

   991 	return cntItem;		

   992 	}

   993 

   994 

   995 /**

   996 Close/unLock an existing contact in the database.

   997 

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

   999 

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

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

  1002 */

  1003 TBool RCntModel::CloseContact(TContactItemId aCntId)

  1004 	{

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

  1006 	if (res == KErrNone)

  1007 		{

  1008 		return ETrue;

  1009 		}

  1010 	return EFalse;

  1011 	}

  1012 

  1013 

  1014 /**

  1015 Start a database transaction.

  1016 */

  1017 TInt RCntModel::BeginDbTransaction() const

  1018 	{

  1019 	return SendReceive(EBeginDbTransaction);

  1020 	}

  1021 

  1022 	

  1023 /**

  1024 Commit a database transaction.

  1025 */

  1026 TInt RCntModel::CommitDbTransaction() const

  1027 	{

  1028 	return SendReceive(EEndDbTransaction);

  1029 	}

  1030 

  1031 	

  1032 /**

  1033 Rollback a database transaction.

  1034 */

  1035 TInt RCntModel::RollbackDbTransaction() const

  1036 	{

  1037 	return SendReceive(ERollbackDbTransaction);

  1038 	}

  1039 

  1040 

  1041 /**

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

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

  1044 being completed with an error code.

  1045 

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

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

  1048 time. 

  1049 */

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

  1051 	{

  1052 	TIpcArgs args;

  1053 	args.Set(0, aMicroSeconds);

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

  1055 	}

  1056 

  1057 	

  1058 /**

  1059 Change the existing contact view definition on the server.

  1060 

  1061 @param aView The new contact view defintion.

  1062 */

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

  1064 	{

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

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

  1067 	}

  1068 

  1069 

  1070 /**

  1071 Add a database event observer.

  1072 

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

  1074 */

  1075 void RCntModel::AddObserverL(MContactDbObserver& aObserver)

  1076 	{

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

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

  1079 	if (!iDbNotifyMonitor)

  1080 		{

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

  1082 		}

  1083 	iDbNotifyMonitor->AddObserverL(aObserver);

  1084 	}

  1085 

  1086 	

  1087 /**

  1088 Remove a database event observer.

  1089 

  1090 @param aObserver Observer callback inteface to be removed.

  1091 */

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

  1093 	{

  1094 	if (iDbNotifyMonitor)

  1095 		{

  1096 		iDbNotifyMonitor->RemoveObserver(aObserver);

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

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

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

  1100 			{

  1101 			delete iDbNotifyMonitor;

  1102 			iDbNotifyMonitor = NULL;

  1103 			}

  1104 		}

  1105 	}

  1106 

  1107 /**

  1108 Add a database event observer.

  1109 

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

  1111 */

  1112 void RCntModel::AddObserverV2L(MContactDbObserverV2& aObserver)

  1113     {

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

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

  1116     if (!iDbNotifyMonitor)

  1117         {

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

  1119         }

  1120     iDbNotifyMonitor->AddObserverV2L(aObserver);

  1121     }

  1122 

  1123     

  1124 /**

  1125 Remove a database event observer.

  1126 

  1127 @param aObserver Observer callback inteface to be removed.

  1128 */

  1129 void RCntModel::RemoveObserverV2(const MContactDbObserverV2& aObserver)

  1130     {

  1131     if (iDbNotifyMonitor)

  1132         {

  1133         iDbNotifyMonitor->RemoveObserverV2(aObserver);

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