1 // Copyright (c) 1997-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 #include "calclient.h"

    17 

    18 #include <s32mem.h>

    19 

    20 #include "agmallocator.h"

    21 #include "agmattachment.h"

    22 #include "agmentry.h"

    23 #include "agmtlsproxy.h"

    24 #include "agmtzrules.h"

    25 #include "agmrptdef.h"

    26 #include "agmcategory.h"

    27 #include "agmcontent.h"

    28 #include "agmserv.h"

    29 #include "agssignal.h"

    30 #include "calattachmentmanagerimpl.h"

    31 #include "calinstance.h"

    32 #include "calentryimpl.h"

    33 #include "agmsortcriteria.h"

    34 #include "calsessionimpl.h"

    35 #include "calcalendarinfoimpl.h"

    36 #include "agmfilechangenotification.h"

    37 

    38 const TUint KDefaultMessageSlots = 3;

    39 

    40 _LIT(KAgendaMutex, "AgnMutex");

    41 

    42 //

    43 // RAgendaServ

    44 //

    45 void RAgendaServ::AddSessionL(const CCalSessionImpl& aSession, TInt& aSessionId)

    46 	{

    47 	__ASSERT_DEBUG(FindSession(aSession) == -1, User::Invariant());

    48 	iCalSessions.AppendL(&aSession);

    49 	aSessionId = ++iLastSessionId;

    50 	}

    51 

    52 TBool RAgendaServ::RemoveSession(const CCalSessionImpl& aSession)

    53 	{

    54 	TInt pos = FindSession(aSession);

    55 	if (pos != KErrNotFound)

    56 	    {

    57 	    iCalSessions.Remove(pos);

    58 	    }

    59 	return (iCalSessions.Count()>0)?ETrue:EFalse;

    60 	}

    61 

    62 TInt RAgendaServ::FindSession(const CCalSessionImpl& aSession)

    63 	{

    64 	const TInt count = iCalSessions.Count();

    65 	for(TInt ii=0; ii<count; ++ii)

    66 		{

    67 		if(&aSession == iCalSessions[ii])

    68 			{

    69 			return ii;

    70 			}

    71 		}

    72 	return -1;

    73 	}

    74 

    75 void RAgendaServ::IncreaseRef()

    76 	{

    77 	iReferenceCount++;

    78 	}

    79 

    80 TInt RAgendaServ::DecreaseRef()

    81 	{

    82 	iReferenceCount--;

    83 	__ASSERT_ALWAYS( iReferenceCount >= 0, User::Invariant());

    84 	return iReferenceCount;

    85 	}

    86 

    87 RAgendaServ* RAgendaServ::NewL()

    88 /** Constructs a new RAgendaServ, initialising all member data to NULL.

    89 

    90 @return A pointer to the client interface to the agenda server. */

    91 	{

    92 	RAgendaServ* self = new (ELeave) RAgendaServ();

    93 	

    94 	TRAPD(err, self->ConstructL());

    95 	if(err != KErrNone)

    96 	    {

    97 	    delete self;

    98 	    User::Leave(err);

    99 	    }

   100 	

   101 	return self;

   102 	}

   103 

   104  // not derived from CBase, so have to set member data to NULL

   105 RAgendaServ::RAgendaServ()

   106 	: RSessionBase(), iBuffer(NULL),iLastSessionId(0)

   107 	{

   108 	}

   109 

   110 void RAgendaServ::ConstructL()

   111 	{

   112 	iReferenceCount = 0;

   113 	iSimpleEntryAllocator = 0;

   114 	iSimpleEntryAllocator = new (ELeave) CAgnSimpleEntryAllocator;

   115 	CAgnTlsProxy::CreateL(CAgnTlsProxy::TAgnTlsTzRulesType_Client);

   116     iBuffer = CBufFlat::NewL(KInitialBufferSize);

   117     iBuffer->ExpandL(0, KInitialBufferSize);

   118 	}

   119 

   120 RAgendaServ::~RAgendaServ()

   121 /** The destructor frees all resources owned by the server, prior to its destruction. */

   122 	{

   123 	__ASSERT_ALWAYS( iReferenceCount == 0, User::Invariant());

   124 	delete iBuffer;

   125 	CAgnTlsProxy::Release(NULL);	

   126 	delete iSimpleEntryAllocator;

   127 	iCalSessions.Close();

   128 	}

   129 

   130 // Connect to the server

   131 

   132 //

   133 // CAgnServer

   134 //

   135 

   136 // Static function to create a new thread or process, depending upon the

   137 // variant. For marm builds, the AGSVEXE.EXE program is run, which 

   138 // creates the server objects in a new process

   139 

   140 TInt RAgendaServ::StartServer()

   141 	{

   142 	TRequestStatus stat;

   143 	TAgnSignal signal(stat);

   144 

   145 	

   146 	RProcess server;

   147 	// Locate the server on all drives (Y-A, then Z)

   148 

   149 	TInt ret = server.Create(KAgendaServerExe, signal.Command(), EOwnerThread);

   150 	if (ret!=KErrNone)

   151 		{

   152 		return ret;

   153 		}

   154 	server.SetPriority(EPriorityForeground);

   155 

   156 	server.Rendezvous(stat);

   157 	

   158 	if (stat!=KRequestPending)

   159 		{

   160 		server.Kill(0);		// abort startup

   161 		}

   162 	else

   163 		{

   164 		server.Resume();	// logon OK - start the server

   165 		}

   166 

   167 	

   168 	User::WaitForRequest(stat);

   169 	server.Close();

   170 	return stat.Int();

   171 	}

   172 

   173 TInt RAgendaServ::Connect()

   174 /** Connects the client process to the agenda server. 

   175 

   176 This function must be called before the server can be used.

   177 

   178 @return An error code. KErrNone if successful. */

   179 	{

   180 	RMutex mutex;

   181 	TInt ret = mutex.CreateGlobal(KAgendaMutex);

   182 	if(ret != KErrNone && ret != KErrAlreadyExists)

   183 		{

   184 		return ret;

   185 		}

   186 	ret = mutex.OpenGlobal(KAgendaMutex);	

   187 	if (ret != KErrNone && ret != KErrAlreadyExists)

   188 		{

   189 		return ret;

   190 		}

   191 	mutex.Wait();

   192 	TInt r = DoConnect();

   193 	if (r==KErrNotFound || r==KErrServerTerminated)

   194 		{

   195 		r=StartServer();

   196 		if(r==KErrNone || r==KErrAlreadyExists)

   197 			{

   198 			r=DoConnect();

   199 			}

   200 		}

   201 	mutex.Signal();

   202 	mutex.Close();

   203 	return r;

   204 	}

   205 	

   206 TInt RAgendaServ::DoConnect()

   207 	{

   208 	return CreateSession(KAgendaServerName,Version(), KDefaultMessageSlots);

   209 	}

   210 

   211 

   212 // Return the client side version no.

   213 TVersion RAgendaServ::Version() const

   214 	{

   215 	return (TVersion(KAgnServerMajorVersion,KAgnServerMinorVersion,KAgnServerBuildVersion));

   216 	}

   217 

   218 

   219 

   220 //

   221 // Server Utility Functions

   222 

   223 void RAgendaServ::Panic(TAgnClientPanic aPanic) const

   224 	{

   225 	_LIT(KAgendaClient,"AgendaClient");

   226 	User::Panic(KAgendaClient, aPanic);

   227 	}

   228 

   229 /** 

   230 Checks the size of the incoming buffer, and if it is larger

   231 than the size of the buffer already defined, allocates enough

   232 space in aBuffer, and transfers the data from the server

   233 

   234 @capability ReadUserData

   235 */

   236 CBufFlat* RAgendaServ::CreateTransmitBufferL(TInt aBufferSize) const

   237 	{

   238 	CBufFlat* buffer = NULL;

   239 	

   240 	if (aBufferSize > KInitialBufferSize)

   241 		{

   242 		// Create a buffer with granularity of aBufferSize

   243 		buffer = CBufFlat::NewL(aBufferSize);

   244 		CleanupStack::PushL(buffer);

   245 

   246 		// Extends the size of the bufferr by the required size

   247 		buffer->ExpandL(0,aBufferSize);

   248 

   249 		// Transfer the data from the server

   250 		TPtr8 bufptr = buffer->Ptr(0);

   251 		TIpcArgs args(&bufptr);

   252 		User::LeaveIfError(SendReceive(ETransmitBuffer,args));

   253 		CleanupStack::Pop(buffer);

   254 		}

   255 	return buffer;

   256 	}

   257 

   258 

   259 void RAgendaServ::ExternalizeFilterL(const TAgnFilter& aFilter, RWriteStream& aStream) const

   260 	{

   261 	aFilter.ExternalizeL(aStream);

   262 	}

   263 

   264 

   265 CAgnSimpleEntry* RAgendaServ::InternalizeSimpleEntryL(RReadStream& aStream) const

   266 	{

   267 	CCalEntry::TType entryType = static_cast<CCalEntry::TType>( aStream.ReadUint32L() );

   268 		

   269 	CAgnSimpleEntry* entry = iSimpleEntryAllocator->CreateSimpleEntryL(entryType);

   270 	//to cleanup CAgnSortEntry pointer, if a leave happens during internalize.

   271 	TCleanSimpleEntry simpleEntryCleanupItem(*entry, *iSimpleEntryAllocator);

   272 	CleanupStack::PushL(TCleanupItem(TCleanSimpleEntry::DestroySimpleEntry,&simpleEntryCleanupItem));

   273 	entry->InternalizeL(aStream, ETrue);

   274     CleanupStack::Pop(&simpleEntryCleanupItem);

   275 	

   276 	return ( entry );

   277 	}

   278 

   279 /**

   280 @capability None

   281 */

   282 void RAgendaServ::OpenAgendaL(const CCalSessionImpl& aSession, const TDesC& aFileName, CalCommon::TCalFileVersionSupport& aStatus, TInt64& aFileId, TCalCollectionId& aCallectionId)

   283 	{

   284     CBufFlat* streamBuffer = CBufFlat::NewL(aFileName.Size()+ sizeof(TUint8));

   285     CleanupStack::PushL(streamBuffer);

   286     RBufWriteStream bufStream;

   287     bufStream.Open(*streamBuffer);

   288     CleanupClosePushL(bufStream);

   289     bufStream << aFileName;

   290     bufStream.WriteInt32L(aSession.SessionId());

   291     CleanupStack::PopAndDestroy(&bufStream);

   292     TPtr8 readPtr = streamBuffer->Ptr(0);

   293     TPckgBuf<CalCommon::TCalFileVersionSupport> statusPckg(aStatus);

   294     TPckgBuf<TInt64> fileId(aFileId);

   295     TPckgBuf<TCalCollectionId> shortFileId(aCallectionId);

   296     TIpcArgs args(&readPtr, &statusPckg, &fileId, &shortFileId);  

   297     TInt err = SendReceive(EOpenAgenda,args);

   298     CleanupStack::PopAndDestroy(streamBuffer);

   299     if(err != KErrAlreadyExists)

   300         {

   301         aStatus = statusPckg();

   302         User::LeaveIfError(err);

   303         aFileId = fileId();

   304         aCallectionId = shortFileId();

   305         }

   306 	}

   307 	

   308 void RAgendaServ::WaitUntilLoadedL(TCalCollectionId aCallectionId)

   309 	{

   310 	TIpcArgs args(0, aCallectionId);//0 argument means not to report the progess

   311 	TRequestStatus status = KRequestPending;

   312 	SendReceive(EStartBuildIndex, args, status);

   313 	User::WaitForRequest(status);

   314 	User::LeaveIfError(status.Int());

   315 	}

   316 

   317 /** 

   318 Closes the file that is open in the current agenda server session. 

   319 @capability None

   320 */

   321 void RAgendaServ::CloseAgenda(TInt aSessionId)

   322 	{

   323 	TIpcArgs args(aSessionId);

   324 	SendReceive(ECloseAgenda, args);

   325 	}

   326 

   327 /** 

   328 Fetches a complete entry from the server

   329 @capability ReadUserData

   330 */

   331 CAgnEntry* RAgendaServ::FetchEntryL(TAgnEntryId& aId, TInt64 aFileId) const

   332 	{

   333 	TPckg<TAgnEntryId> entryId(aId);

   334 	TPckgBuf<TInt> size;

   335 	TPtr8 ptr = iBuffer->Ptr(0);

   336 

   337 	if (aId.IsNullId())

   338 		{

   339 		return NULL;

   340 		}

   341 	TPckgBuf<TInt64> fileId(aFileId);

   342 	TIpcArgs args(&ptr, &entryId, &size, &fileId);

   343 	User::LeaveIfError(SendReceive(EFetchEntry,args));

   344 

   345 	return ReadEntryFromServerSessionL(size());	

   346 	}

   347 

   348 /** Fetches a complete entry from the server

   349 @capability ReadUserData

   350 */

   351 CAgnEntry* RAgendaServ::FetchEntryL(TCalLocalUid aId, TInt64 aFileId) const

   352 	{

   353 	TPckg<TCalLocalUid> entryId(aId);

   354 	TPckgBuf<TInt> size;

   355 	TPtr8 ptr = iBuffer->Ptr(0);

   356 	TPckgBuf<TInt64> fileId(aFileId);

   357 	TIpcArgs args(&ptr, &entryId, &size, &fileId);

   358 	User::LeaveIfError(SendReceive(EFetchEntryByUID,args));

   359 	return ReadEntryFromServerSessionL(size());

   360 	}

   361 

   362 

   363 /* Internalize agenda entry from buffer 

   364 

   365 @capability ReadUserData

   366 @param aBufferSize size of buffer 

   367 @return agenda entry internalized from buffer

   368 */

   369 CAgnEntry* RAgendaServ::ReadEntryFromServerSessionL(TInt aBufferSize) const

   370 	{

   371 	if (aBufferSize==0) // if size = 0, there entry has already been deleted

   372 		{

   373 		return NULL;

   374 		}

   375 

   376 	RBufReadStream readStream;

   377 	// Create a transfer buffer, and set where to read the data from

   378 	CBufFlat* buffer = CreateTransmitBufferL(aBufferSize);

   379 	if (buffer)

   380 		{

   381 		readStream.Open(*buffer);

   382 		}

   383 	else

   384 		{

   385 		readStream.Open(*iBuffer);

   386 		}

   387 	CleanupStack::PushL(buffer);

   388 

   389 	CAgnEntry* entry = CreateEntryFromBufferStreamL(readStream);

   390 	readStream.Close();

   391 	CleanupStack::PopAndDestroy(buffer);

   392 

   393 	return entry;

   394 	}

   395 

   396 CAgnEntry* RAgendaServ::CreateEntryFromBufferStreamL(RReadStream& aReadStream) const

   397 	{

   398 	CCalEntry::TType entryType = (CCalEntry::TType)aReadStream.ReadUint32L();

   399 	

   400 	CAgnEntry* entry = CAgnEntry::NewL(entryType);

   401 	CleanupStack::PushL(entry);

   402 	entry->InternalizeFromBufferL(aReadStream);

   403 	CleanupStack::Pop(entry);

   404 	return entry;

   405 	}

   406 

   407 /** 

   408 Get a lite entry from the server

   409 (Lite-entries are just time information, with no text, etc)

   410 @capability ReadUserData

   411 */

   412 CAgnSimpleEntry* RAgendaServ::GetSimpleEntryL(const TAgnEntryId& aId, TCalCollectionId aCallectionId) const

   413 	{

   414 	TPckgBuf<TInt> size;

   415 

   416 	TPtr8 ptr = iBuffer->Ptr(0);

   417 

   418 	if (aId.IsNullId())

   419 		{

   420 		return NULL;

   421 		}

   422 	CBufFlat* streamBuffer = CBufFlat::NewL(sizeof(TAgnInstance));

   423 	CleanupStack::PushL(streamBuffer);

   424 	RBufWriteStream bufStream;

   425 	bufStream.Open(*streamBuffer);

   426 	CleanupClosePushL(bufStream);

   427 

   428 	bufStream << aId;

   429 	CleanupStack::PopAndDestroy(&bufStream);

   430 	TPtr8 readPtr = streamBuffer->Ptr(0);

   431 	TIpcArgs args(&ptr, &readPtr, &size, aCallectionId);

   432 	User::LeaveIfError(SendReceive(EFetchSimpleEntry,args));

   433 	CleanupStack::PopAndDestroy(streamBuffer);

   434 	if (size() == 0)

   435 		{

   436 		User::Leave(KErrNotFound);

   437 		}

   438 

   439 	RBufReadStream readStream;

   440 

   441 	CBufFlat* buffer = CreateTransmitBufferL(size());

   442 	if (buffer)

   443 		{

   444 		readStream.Open(*buffer);

   445 		}

   446 	else

   447 		{

   448 		readStream.Open(*iBuffer);

   449 		}

   450 

   451 	CleanupStack::PushL(buffer);

   452 

   453 	CAgnSimpleEntry* entry = NULL;

   454 

   455 	if (readStream.ReadUint8L())

   456 		{

   457 		entry = InternalizeSimpleEntryL(readStream);

   458 		entry->SetCollectionId(aCallectionId);

   459 		}

   460 	

   461 	readStream.Close();

   462 	

   463 	CleanupStack::PopAndDestroy(buffer);

   464 	

   465 	// Don't leave here for a NULL entry could be a race with an entry delete

   466 	return entry;

   467 	}

   468 

   469 /** 

   470 Get a lite entry from the server

   471 (Lite-entries are just time information, with no text, etc)

   472 @capability ReadUserData

   473 */

   474 CAgnSimpleEntry* RAgendaServ::GetSimpleEntryL(TCalCollectionId aCallectionId, TUint32 aId) const

   475 	{

   476 //	TPckg<TAgnEntryId> entryId(aId);

   477 	TPckgBuf<TInt> size;

   478 

   479 	TPtr8 ptr = iBuffer->Ptr(0);

   480 	if (aId == 0)

   481 		{

   482 		return NULL;

   483 		}

   484 	CBufFlat* streamBuffer = CBufFlat::NewL(sizeof(TUint8)+sizeof(TUint32));

   485 	CleanupStack::PushL(streamBuffer);

   486 	RBufWriteStream bufStream;

   487 	bufStream.Open(*streamBuffer);

   488 	CleanupClosePushL(bufStream);

   489 

   490 	bufStream << aId;

   491 	CleanupStack::PopAndDestroy(&bufStream);

   492 	TPtr8 readPtr = streamBuffer->Ptr(0);

   493 	TIpcArgs args(&ptr, &readPtr, &size, aCallectionId);

   494 	User::LeaveIfError(SendReceive(EFetchSimpleEntryByUID,args));

   495 	CleanupStack::PopAndDestroy(streamBuffer);

   496 	if (size() == 0)

   497 		{

   498 		User::Leave(KErrNotFound);

   499 		}

   500 

   501 	RBufReadStream readStream;

   502 

   503 	CBufFlat* buffer = CreateTransmitBufferL(size());

   504 	if (buffer)

   505 		{

   506 		readStream.Open(*buffer);

   507 		}

   508 	else

   509 		{

   510 		readStream.Open(*iBuffer);

   511 		}

   512 

   513 	CleanupStack::PushL(buffer);

   514 

   515 	CAgnSimpleEntry* entry = NULL;

   516 

   517 	if (readStream.ReadUint8L())

   518 		{

   519 		entry = InternalizeSimpleEntryL(readStream);

   520 		entry->SetCollectionId(aCallectionId);

   521 		}

   522 	

   523 	readStream.Close();

   524 	

   525 	CleanupStack::PopAndDestroy(buffer);

   526 	

   527 	// Don't leave here for a NULL entry could be a race with an entry delete

   528 	return entry;

   529 	}

   530 	

   531 /** Get an array of lite entries from the server

   532 

   533 On return the instance ids and lite entries will have corresponding indices in the arrays 

   534 (Lite-entries are just time information, with no text, etc)

   535 

   536 @param aIds The instance ids of the lite entries to fetch

   537 @param aLiteEntries on return will contain the fetched lite entries.

   538 

   539 @capability ReadUserData

   540 */

   541 void RAgendaServ::GetSimpleEntryL(const RArray<TAgnInstance>& aEntryIds, RPointerArray<CAgnSimpleEntry>& aLiteEntries) const

   542 	{

   543 	// only fetches KMaxNumToFetch at a time from the server

   544 	const TInt KMaxNumToFetch(32);

   545 	const TInt KBufferSize = (KMaxNumToFetch + 1) * sizeof(TUint32); // enough room to write KNumToFetch entries plus a count

   546 	

   547 	const TInt KEntryIdCount(aEntryIds.Count());

   548 	for (TInt entriesFetchedSoFar(0) ; entriesFetchedSoFar < KEntryIdCount ;)

   549 		{

   550 		CBufFlat* instanceIdBuffer = CBufFlat::NewL(KBufferSize);

   551 		CleanupStack::PushL(instanceIdBuffer);

   552 		RBufWriteStream bufStream;

   553 		bufStream.Open(*instanceIdBuffer);

   554 			

   555 		// Externalize up to KMaxNumToFetch instance ids

   556 		// KNumToFetch will be the total number of fetched TAgnLiteEntrys fetched this time

   557 		const TInt KNumToFetch = ((KEntryIdCount - entriesFetchedSoFar) < KMaxNumToFetch) ? KEntryIdCount : entriesFetchedSoFar + KMaxNumToFetch;

   558 		bufStream.WriteUint32L(KNumToFetch - entriesFetchedSoFar);

   559 		for (; entriesFetchedSoFar < KNumToFetch ; ++entriesFetchedSoFar)

   560 			{

   561 			bufStream << aEntryIds[entriesFetchedSoFar];

   562 			}

   563 			

   564 		bufStream.CommitL();

   565 		bufStream.Close();

   566 		TPtr8 entryIds = instanceIdBuffer->Ptr(0);

   567 		

   568 		TPckgBuf<TInt> size;

   569 		TPtr8 ptr = iBuffer->Ptr(0);

   570 		

   571 		// call the server

   572 		TIpcArgs args(&ptr, &entryIds, &size);

   573 		User::LeaveIfError(SendReceive(EFetchSimpleEntries, args));

   574 			

   575 		// open the read stream

   576 		RBufReadStream readStream;

   577 		CBufFlat* liteEntryBuffer = CreateTransmitBufferL(size());

   578 		if (liteEntryBuffer)

   579 			{

   580 			readStream.Open(*liteEntryBuffer);

   581 			}

   582 		else

   583 			{

   584 			readStream.Open(*iBuffer);

   585 			}

   586 		CleanupStack::PushL(liteEntryBuffer);

   587 

   588 		// Read the lite entries from the buffer 

   589 		const TCalCollectionId KLiteEntryCount(readStream.ReadUint8L());

   590 		for (TInt i(0) ; i < KLiteEntryCount ; ++i)

   591 			{

   592 			if (readStream.ReadUint8L())

   593 				{

   594 				CAgnSimpleEntry* ptr = InternalizeSimpleEntryL(readStream);

   595 				ptr->SetCollectionId(readStream.ReadUint8L());

   596 				TInt err = aLiteEntries.Append(ptr);

   597 				if (err != KErrNone)

   598 					{

   599 					iSimpleEntryAllocator->Delete(ptr);

   600 					User::Leave(err);

   601 					}

   602 				}

   603 			}

   604 		

   605 		readStream.Close();

   606 		

   607 		CleanupStack::PopAndDestroy(liteEntryBuffer);

   608 		CleanupStack::PopAndDestroy(instanceIdBuffer);

   609 		}

   610 	}

   611 

   612 /** Get an array of lite entries from the server

   613 

   614 On return the instance ids and lite entries will have corresponding indices in the arrays 

   615 (Lite-entries are just time information, with no text, etc)

   616 

   617 @param aUid The UID of the lite entries to fetch

   618 @param aLiteEntries on return will contain the fetched lite entries.

   619 

   620 @capability ReadUserData

   621 */

   622 void RAgendaServ::FetchSimpleEntriesByGuidL(const TDesC8& aUid, RPointerArray<CAgnSimpleEntry>& aLiteEntries, RArray<TInt> aFileIds) const

   623 	{

   624 	const TInt countFile = aFileIds.Count();

   625 	const TInt lenUid = aUid.Length();

   626 	

   627 	CBufFlat* inBuffer = CBufFlat::NewL(sizeof(countFile*8) + lenUid);

   628 	CleanupStack::PushL(inBuffer);

   629 	RBufWriteStream bufStream;

   630 	CleanupClosePushL(bufStream);

   631 	bufStream.Open(*inBuffer);

   632 	bufStream.WriteInt16L(lenUid);

   633 	bufStream.WriteL(aUid, lenUid);

   634 	bufStream.WriteInt16L(countFile);

   635 	for(TInt ii=0; ii<countFile;++ii)

   636 		{

   637 		bufStream.WriteUint8L(aFileIds[ii]);

   638 		}

   639 	CleanupStack::PopAndDestroy(&bufStream);

   640 	

   641 	TPtr8 paramsPtr = inBuffer->Ptr(0);

   642 

   643 	TPckgBuf<TInt> size(0);

   644 	TPtr8 ptr = iBuffer->Ptr(0);

   645 	TIpcArgs args(&ptr, &size, &paramsPtr);

   646 	User::LeaveIfError(SendReceive(EFetchSimpleEntriesByGuid, args));

   647 	CleanupStack::PopAndDestroy(inBuffer);

   648 	// open the read stream

   649 	RBufReadStream readStream;

   650 	CBufFlat* liteEntryBuffer = CreateTransmitBufferL(size());

   651 	if (liteEntryBuffer)

   652 		{

   653 		readStream.Open(*liteEntryBuffer);

   654 		}

   655 	else

   656 		{

   657 		readStream.Open(*iBuffer);

   658 		}

   659 	CleanupStack::PushL(liteEntryBuffer);

   660 

   661 	// Read the lite entries from the buffer 

   662 	const TUint32 KLiteEntryCount(readStream.ReadUint32L());

   663 	for (TInt i(0) ; i < KLiteEntryCount ; ++i)

   664 		{

   665 		CAgnSimpleEntry* ptr = InternalizeSimpleEntryL(readStream);

   666 		ptr->SetCollectionId(readStream.ReadUint8L());

   667 		TInt err = aLiteEntries.Append(ptr);

   668 		if (err != KErrNone)

   669 			{

   670 			iSimpleEntryAllocator->Delete(ptr);

   671 			User::Leave(err);

   672 			}

   673 		}

   674 	

   675 	readStream.Close();

   676 	

   677 	CleanupStack::PopAndDestroy(liteEntryBuffer);

   678 	}

   679 

   680 /** Updates an existing entry on the server

   681 @param aEntry

   682 @param aTodoPosition

   683 @capability WriteUserData

   684 @capability ReadUserData

   685 @leave

   686 @internalComponent

   687 */

   688 void RAgendaServ::UpdateEntryL(CAgnEntry& aEntry, TBool aDeleteChildren, TCalCollectionId aCallectionId)

   689 	{

   690 	/*

   691 	Check that either (or both) the instance or the unique id of the entry

   692 	passed is not null, otherwise, the update will not occur because the server

   693 	will not know which of its entries it should update.

   694 	*/

   695 	__ASSERT_ALWAYS( !(aEntry.EntryId().IsNullId() && aEntry.LocalUid() == 0 && aCallectionId == NULL), User::Leave(KErrNotFound));

   696 	

   697 	aEntry.VerifyBeforeStoreL();

   698 	

   699 	RBufWriteStream bufStream;

   700 

   701 	bufStream.Open(*iBuffer);

   702 

   703 	bufStream.WriteUint32L(aEntry.Type());

   704 	bufStream.WriteUint8L(aDeleteChildren);

   705 

   706 	// Set regardless.

   707 	aEntry.SetLastModifiedDate();

   708 

   709 	// Externalize the entry details to the buffer

   710 	// Any rich text components will be stored in the textStream buffer

   711 	aEntry.ExternalizeToBufferL(bufStream);

   712 	bufStream.CommitL();

   713 	bufStream.Close();

   714 

   715 	// Get the sizes of the buffers

   716 	TInt size(iBuffer->Size());

   717 	

   718 	// Get the pointer of the buffers

   719 	TPtr8 ptr = iBuffer->Ptr(0);

   720 	

   721 	// The entry id	

   722 	TPckgBuf<TAgnEntryId> entryId;

   723 	TIpcArgs args(size, &ptr, &entryId, aCallectionId);

   724 	

   725 	User::LeaveIfError(SendReceive(EUpdateEntry, args));	

   726 	aEntry.SetEntryId(entryId());	

   727 	}

   728 

   729 /** 

   730 Add a new enty to the server

   731 @capability WriteUserData

   732 @capability ReadUserData

   733 */

   734 TAgnEntryId RAgendaServ::AddEntryL(CAgnEntry& aEntry, TInt64 aFileId)

   735 	{

   736 	aEntry.VerifyBeforeStoreL();

   737 	

   738 	RBufWriteStream bufStream;

   739 

   740 	bufStream.Open(*iBuffer);

   741 	

   742 	bufStream.WriteUint32L(aEntry.Type());

   743 

   744 	aEntry.ExternalizeToBufferL(bufStream);

   745 

   746 	bufStream.CommitL();

   747 	bufStream.Close();

   748 

   749 	// Get the sizes of the buffers

   750 	TInt size = iBuffer->Size();

   751 	

   752 	// Get the pointer of the buffers

   753 	TPtr8 ptr = iBuffer->Ptr(0);

   754 	

   755 	// The entry Id and unique Id

   756 	TPckgBuf<TAgnEntryParameters> entryParams;

   757 	TPckgBuf<TInt64> fileId(aFileId);

   758 	TIpcArgs args(size, &ptr, &entryParams, &fileId);	

   759 	

   760 	User::LeaveIfError(SendReceive(EAddEntry, args));

   761 	

   762 	aEntry.SetEntryId(entryParams().iEntryId);

   763 	aEntry.SetLocalUid(entryParams().iLocalId);

   764 	if (entryParams().iRecurrenceId != Time::NullTTime())

   765 		{

   766 		TAgnCalendarTime agnRecId;

   767 		if (aEntry.TimeMode() == MAgnCalendarTimeMode::EFloating)

   768 			{

   769 			agnRecId.SetFloatingL(entryParams().iRecurrenceId);

   770 			}

   771 		else

   772 			{

   773 			agnRecId.SetLocalL(entryParams().iRecurrenceId);

   774 			}

   775 		aEntry.UpdateRecurrenceIdL(agnRecId);

   776 		}

   777 	aEntry.SetLastModifiedDateUtc(entryParams().iLastModifiedDateUtc);

   778 	if (aEntry.TimeMode() != MAgnCalendarTimeMode::EFloating &&	aEntry.RptDef() != NULL	)

   779 		{

   780 		CAgnTzRules* tzRules = aEntry.RptDef()->AgnTzRules();

   781 		if(tzRules != NULL)

   782 			{

   783 			tzRules->SetTzZoneStreamId(entryParams().iTzStreamId);

   784 			tzRules->SetSystemTzRule(entryParams().iSystemTzRule);

   785 			}

   786 		}

   787 	

   788 

   789 	SendFileAttachmentHandlesL(aEntry, aFileId);

   790 

   791 	return entryParams().iEntryId;

   792 	}

   793 

   794 /**

   795 For all attachments on this entry, find out whether they are file attachments.

   796 If it contains a file handle, then it must be transferred to the server through a separate IPC call (TransferFileHandleToServerL).

   797 If it contains binary data, then a file handle must be fetched from the server, to which the binary data 

   798 will be written directly (WriteBinaryDataToNewAttachmentFileL).

   799 */

   800 void RAgendaServ::SendFileAttachmentHandlesL(CAgnEntry& aEntry, TInt64 aFileId)

   801 	{

   802 	const TInt KAttachmentCount = aEntry.AttachmentCount();

   803 	for (TUint32 i = 0; i < KAttachmentCount; i++)

   804 		{

   805 		CAgnAttachment& attach = aEntry.Attachment(i);

   806 		if (attach.Type() == CCalContent::EDispositionInline)

   807 			{

   808 			// This is a file attachment

   809 			CAgnAttachmentFile* fileAttach = static_cast<CAgnAttachmentFile*>(&attach);

   810 			if (fileAttach->IsFileHandleSet())

   811 				{

   812 				// This is a file attachment with a file handle

   813 				TransferFileHandleToServerL(aEntry.LocalUid(), i, *fileAttach, aFileId);

   814 				}

   815 			else if (fileAttach->Uid() == 0 && fileAttach->Content().Length() > 0)

   816 				{

   817 				// This is a new file attachment (uid==0) with binary data

   818 				WriteBinaryDataToNewAttachmentFileL(aEntry, i, aFileId);

   819 				}

   820 			}

   821 		}

   822 	}

   823 

   824 /**

   825 Store a new attachment with a file handle. The file handle is transferred to the Calendar server, which moves the file to 

   826 the Calendar store.

   827 On the server-side, this will also update the entry containing this attachment with the new attachment metadata.

   828 @capability WriteUserData

   829 */

   830 void RAgendaServ::TransferFileHandleToServerL(TCalLocalUid aLocalUid, TInt aAttachmentIndex, CAgnAttachmentFile& aFileAttachment, TInt64 aFileId)

   831 	{

   832 	TAttachmentData attachData;

   833 	attachData.iLocalUid = aLocalUid;

   834 	attachData.iAttachmentIndex = aAttachmentIndex;

   835 	TPckg<TCalAttachmentUid> attachUid(0);

   836 	

   837 	CBufFlat* paramsBuffer = CBufFlat::NewL(sizeof(TInt64) + sizeof(TAttachmentData));

   838 	CleanupStack::PushL(paramsBuffer);

   839 	RBufWriteStream bufStream;

   840 	CleanupClosePushL(bufStream);

   841 	bufStream.Open(*paramsBuffer);

   842 	bufStream.WriteUint32L(attachData.iLocalUid);

   843 	bufStream.WriteInt16L(attachData.iAttachmentIndex);

   844 	bufStream << aFileId;

   845 	CleanupStack::PopAndDestroy(&bufStream);

   846 	 	

   847 	TPtr8 paramsPtr = paramsBuffer->Ptr(0);

   848 	TIpcArgs args(&paramsPtr, &attachUid);

   849 	// Detach file handle from attachment, if TransferToServer or SendReceive(ETransferAttachmentFileToServer) fail,

   850 	// then the fileHandle must not be deleted.

   851 	RFile& fileHandle = const_cast<RFile&>(aFileAttachment.FileHandle()); 

   852 	CleanupClosePushL(fileHandle);

   853 

   854 	// note that the following line will panic if the RFs that contains 

   855 	// this file handle is not shared by calling RFs::ShareProtected()

   856 	User::LeaveIfError(aFileAttachment.FileHandle().TransferToServer(args, KTransferAttachmentToSrvFsArgIndex, KTransferAttachmentToSrvFileArgIndex));

   857 	User::LeaveIfError(SendReceive(ETransferAttachmentFileToServer, args));//replace the file in the same drive

   858 	CleanupStack::PopAndDestroy(&fileHandle);

   859 	if(attachUid() == 0)

   860 		{//When the Drive is different from the default one, the server adopt the handle and will move the attachment file after the file handle is closed.

   861 		User::LeaveIfError(SendReceive(EMoveFileToServer, args));

   862 		}

   863 	CleanupStack::PopAndDestroy(paramsBuffer);

   864 	aFileAttachment.SetHasFileHandle(EFalse);

   865 	aFileAttachment.SetUid(attachUid());

   866 	}

   867 

   868 /**

   869 Store a new attachment from binary data. A new file handle is created on the Calendar server, and this is transferred

   870 to the client side so that the binary data can be written directly.

   871 On the server-side, this will also update the entry containing this attachment with the new attachment metadata.

   872 @capability WriteUserData

   873 */

   874 void RAgendaServ::WriteBinaryDataToNewAttachmentFileL(CAgnEntry& aEntry, TInt aAttachmentIndex, TInt64 aFileId)

   875 	{

   876 	CAgnAttachmentFile* attachment = static_cast<CAgnAttachmentFile*>(&aEntry.Attachment(aAttachmentIndex));

   877 

   878 	// package up data required to identify this attachment on server side.

   879 	TAttachmentData data;

   880 	data.iLocalUid = aEntry.LocalUid();

   881 	data.iAttachmentIndex = aAttachmentIndex;

   882 	if (attachment->FileName().Length() > 0)

   883 		{

   884 		data.iDrive = attachment->FileName().Left(1);

   885 		}

   886 	else

   887 		{

   888 		data.iDrive = KNullDesC;

   889 		}

   890 

   891 	TPckg<TAttachmentData> pckgData(data);

   892 	TPckg<TInt> pckgSubSessionHandle(0);  // initialise	

   893 	TPckgBuf<TInt64> fileId(aFileId);

   894 	

   895 	TIpcArgs args(&pckgData, &pckgSubSessionHandle, &fileId);

   896 	

   897 	TInt dataSize = attachment->Content().Length();

   898 	args.Set(3, dataSize);

   899 

   900 	// call server side to create new file and update entry

   901 	const TInt KSessionHandle = SendReceive(ETransferFileToClientToWrite, args);

   902 	User::LeaveIfError(KSessionHandle);

   903 

   904 	// fetch file handle and write binary data to it

   905 	RFile newFileHandle;

   906 	CleanupClosePushL(newFileHandle);

   907 	User::LeaveIfError(newFileHandle.AdoptFromServer(KSessionHandle, pckgSubSessionHandle()));

   908 	User::LeaveIfError(newFileHandle.Write(attachment->Content()));

   909 	CleanupStack::PopAndDestroy(&newFileHandle); // newFileHandle.Close();

   910 	}

   911 	

   912 /**

   913 Fetch file handle for a file attachment.

   914 @capability ReadUserData

   915 */

   916 void RAgendaServ::FetchFileHandleL(RFile& aFileHandle, TCalAttachmentUid aAttachmentUid, TInt64 aFileId)

   917 	{

   918 	TPckg<TInt> pckgSubSessionHandle(0);  // initialise

   919 	TPckgBuf<TInt64> fileId(aFileId);

   920 	TIpcArgs args(aAttachmentUid, &pckgSubSessionHandle, &fileId);

   921 

   922 	TInt sessionHandle = SendReceive(ETransferAttachmentFileToClient, args);

   923 	User::LeaveIfError(sessionHandle);

   924 	User::LeaveIfError(aFileHandle.AdoptFromServer(sessionHandle, pckgSubSessionHandle()));

   925 	}

   926 

   927 /**

   928 Fetch all file attachments in the order specified and add them to the iterator.

   929 @capability ReadUserData

   930 */

   931 void RAgendaServ::FetchAttachmentsL(CCalAttachmentIteratorImpl& aIteratorImpl, CCalAttachmentManager::TSortOrder aSortOrder, TInt64 aFileId)

   932 	{

   933 	TPtr8 bufptr = iBuffer->Ptr(0);

   934 	TPckg<TInt> size(0);

   935 	TPckgBuf<TInt64> fileId(aFileId);

   936 	// make server request

   937 	TIpcArgs args(&bufptr, &size, aSortOrder, &fileId);

   938 	User::LeaveIfError(SendReceive(EFetchSortedAttachments, args));

   939 	

   940 	RBufReadStream readStream;

   941 	CBufFlat* buffer = CreateTransmitBufferL(size());

   942 	if (buffer)

   943 		{

   944 		readStream.Open(*buffer);

   945 		}

   946 	else

   947 		{

   948 		readStream.Open(*iBuffer);

   949 		}

   950 	

   951 	CleanupStack::PushL(buffer);

   952 	// internalize array from readStream

   953 	const TInt KCount = readStream.ReadUint32L();

   954 

   955 	TCalAttachmentUid attachUid;

   956 	for (TInt i = 0; i < KCount; ++i)

   957 		{

   958 		readStream >> attachUid;

   959 		aIteratorImpl.AppendL(attachUid);

   960 		}

   961 	

   962 	readStream.Close();

   963 	CleanupStack::PopAndDestroy(buffer);

   964 	}

   965 

   966 /**

   967 Fetch local UIDs of all entries that reference the attachment specified.

   968 @capability ReadUserData

   969 */

   970 void RAgendaServ::EntriesReferencingFileAttachmentL(RArray<TCalLocalUid>& aUids, const CAgnAttachment& aAttachment, TInt64 aFileId)

   971 	{

   972 	if (aAttachment.Uid() && aAttachment.Type() == CCalContent::EDispositionInline)

   973 		{

   974 		TPtr8 bufptr = iBuffer->Ptr(0);

   975 		TPckg<TInt> size(0);

   976 		TPckgBuf<TInt64> fileId(aFileId);

   977 		TIpcArgs args(&bufptr, &size, aAttachment.Uid(), &fileId);

   978 		User::LeaveIfError(SendReceive(EEntriesWithAttachment, args));

   979 		

   980 		RBufReadStream readStream;

   981 		CBufFlat* buffer = CreateTransmitBufferL(size());

   982 		if (buffer)

   983 			{

   984 			readStream.Open(*buffer);

   985 			}

   986 		else

   987 			{

   988 			readStream.Open(*iBuffer);

   989 			}

   990 		CleanupStack::PushL(buffer);

   991 

   992 		// internalize local UIDs from readStream

   993 		const TInt KCount = readStream.ReadUint32L();

   994 		TCalLocalUid id;

   995 		for (TInt i = 0; i < KCount; ++i)

   996 			{

   997 			readStream >> id;

   998 			aUids.AppendL(id);

   999 			}

  1000 

  1001 		readStream.Close();

  1002 		CleanupStack::PopAndDestroy(buffer);

  1003 		}

  1004 	}

  1005 

  1006 /**

  1007 Fetch an attachment by its attachment UID. Note attachment UIDs are not exposed to clients, and are just used internally.

  1008 @capability ReadUserData

  1009 */

  1010 CAgnAttachment* RAgendaServ::FetchAttachmentByIdL(TCalAttachmentUid aAttachUid, TInt64 aFileId)

  1011 	{

  1012 	if (aAttachUid == 0)

  1013 		{

  1014 		return NULL;

  1015 		}

  1016 	

  1017 	TPckgBuf<TInt> size(0);

  1018 	TPtr8 ptr = iBuffer->Ptr(0);

  1019 

  1020 	TPckgBuf<TInt64> fileId(aFileId);

  1021 	TIpcArgs args(&ptr, &size, aAttachUid, &fileId);

  1022 	User::LeaveIfError(SendReceive(EFetchAttachmentById, args));

  1023 

  1024 	if (size() == 0) // if size = 0, there entry has already been deleted

  1025 		{

  1026 		return NULL;

  1027 		}

  1028 

  1029 	RBufReadStream readStream;

  1030 	// Create a transfer buffer, and set where to read the data from

  1031 	CBufFlat* buffer = CreateTransmitBufferL(size());

  1032 	if (buffer)

  1033 		{

  1034 		readStream.Open(*buffer);

  1035 		}

  1036 	else

  1037 		{

  1038 		readStream.Open(*iBuffer);

  1039 		}

  1040 	CleanupStack::PushL(buffer);

  1041 

  1042 	CAgnAttachment* attachment = AttachmentFactory::NewAttachmentL(readStream);

  1043 

  1044 	readStream.Close();

  1045 	

  1046 	CleanupStack::PopAndDestroy(buffer);

  1047 	return attachment;

  1048 	}

  1049 

  1050 /** Finds previous instances in the calendar store

  1051 

  1052 @param aParams The filter settings to use when fidning the previous instances

  1053 @param aInstances The previous instances.  Note that the instances will be inserted at the begining of the array

  1054  

  1055 @capability ReadUserData

  1056 */

  1057 void RAgendaServ::PreviousInstancesL(const RArray<TInt64> aFileIds, CArrayFix<TAgnInstance>& aInstances, TFindInstanceParams& aParams) const

  1058 	{

  1059 	const TInt count = aFileIds.Count();

  1060 	CBufFlat* paramsBuffer = CBufFlat::NewL(sizeof(TFindInstanceParams) + count*64);

  1061 	CleanupStack::PushL(paramsBuffer);

  1062 	RBufWriteStream bufStream;

  1063 	CleanupClosePushL(bufStream);

  1064 	bufStream.Open(*paramsBuffer);

  1065 	aParams.ExternalizeL(bufStream);

  1066 	bufStream.WriteInt16L(count);

  1067 	for(TInt ii=0; ii<count;++ii)

  1068 		{

  1069 		bufStream << aFileIds[ii];

  1070 		}

  1071 	CleanupStack::PopAndDestroy(&bufStream);

  1072 	

  1073 	TPtr8 paramsPtr = paramsBuffer->Ptr(0);

  1074 	TInt paramsSize = paramsBuffer->Size();

  1075 	

  1076 	TPckgBuf<TInt> size(0);

  1077 	TPtr8 ptr = iBuffer->Ptr(0);

  1078 	

  1079 	TIpcArgs args(&ptr, &size, &paramsPtr, paramsSize);

  1080 	

  1081 	User::LeaveIfError(SendReceive(EPreviousInstances, args));

  1082 	

  1083 	CleanupStack::PopAndDestroy(paramsBuffer);

  1084 	

  1085 	RBufReadStream readStream;

  1086 	CleanupClosePushL(readStream);

  1087 	

  1088 	CBufFlat* buffer = CreateTransmitBufferL(size());

  1089 	if (buffer)

  1090 		{

  1091 		readStream.Open(*buffer);

  1092 		CleanupStack::PushL(buffer);

  1093 		}

  1094 	else

  1095 		{

  1096 		readStream.Open(*iBuffer);

  1097 		}

  1098 	

  1099 	const TInt KCount(readStream.ReadUint32L());

  1100 

  1101 	for (TInt i(0) ; i < KCount; ++i)

  1102 		{

  1103 		TAgnInstance instance;

  1104 		readStream >> instance;

  1105 		aInstances.InsertL(i,instance);

  1106 		}

  1107 

  1108 	if (buffer)

  1109 		{

  1110 		CleanupStack::PopAndDestroy(buffer);

  1111 		}

  1112 	CleanupStack::PopAndDestroy(&readStream);

  1113 	}

  1114 

  1115 /** Finds the next instances in the calendar store

  1116 

  1117 @param aParams The filter settings to use when finding the next instances

  1118 @param aInstances The next instances.  Note that the instances will be appended to the end of the array

  1119  

  1120 @capability ReadUserData

  1121 */

  1122 void RAgendaServ::NextInstancesL(const RArray<TInt64> aFileIds, CArrayFix<TAgnInstance>& aInstances, const TFindInstanceParams& aParams) const

  1123 	{

  1124 	// Write the find instance setting out to the buffer

  1125 	

  1126 	CBufFlat* paramsBuffer = CBufFlat::NewL(sizeof(TFindInstanceParams));

  1127 	CleanupStack::PushL(paramsBuffer);

  1128 	RBufWriteStream bufStream;

  1129 	CleanupClosePushL(bufStream);

  1130 	bufStream.Open(*paramsBuffer);

  1131 	aParams.ExternalizeL(bufStream);

  1132 	bufStream.WriteInt16L(aFileIds.Count());

  1133 	for(TInt ii=0; ii<aFileIds.Count();++ii)

  1134 		{