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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __AGCLIENT_H__

#define __AGCLIENT_H__

#include "calasynctask.h"

#include "agmattachment.h"

#include "calattachmentmanager.h"

#include "calchangecallback.h"

#include "calinstanceviewimpl.h"

#include "agmids.h"

class CAgnAttachment;

class CAgnContent;

class CAgnCategory;

class CAgnEntry;

class CAgnSimpleEntry;

class CAgnSimpleEntryAllocator;

class CAgnTlsProxy;

class CCalAttachmentIteratorImpl;

class TAgnFilter;

class TAgnInstanceId;

class RFile;

class CCalCalendarInfoImpl;

class CAgnFileChangeInfo;

/**

@internalAll

@released

*/

enum TAgnClientPanic

	{

	ELockError =	-1,

	EBufferError =	-2,

	EStreamIdError =-3,

	EUnknownType =	-4,

	ENullEntry   =  -5,

	EBadModel	 =  -6,

	EServerDeath =  -7

	};

class RAgendaServ : public RSessionBase

/** The client interface to the agenda server. 

This class accesses agenda data by sending messages synchronously to the server.

This allows shared access to an agenda file by more than one client. 

Most functions in this class should not be used directly. If there is a 

corresponding version of the function in the model class, that should be used 

instead.

Note that a separate instance of the RAgendaServ class is required for each 

agenda file that is open. Only one file can be open at any one time in 

the same server session.

The API is used as follows:

@code

RAgendaServ* agnServer = RAgendaServ::NewL(); // allocate and construct server session

CleanupStack::PushL(agnServer); // ensure object is deleted

agnServer->Connect(); // connect to the server

CleanupClosePushL(*agnServer); // ensure that the session's Close() method gets called

CAgnEntryModel* model = CAgnEntryModel::NewL(); // allocate and construct model

CleanupStack::PushL(model);

model->SetServer(agnServer); // set model's server session pointer

model->OpenL(fileName) // open file using server

// ...Use agenda model API as normal - invokes corresponding server functions

CleanupStack::PopAndDestroy(3); // model, close session with server, agnServer

@endcode 

@internalAll

@released

*/

	{

public:

	// Server Connection functions

	void IncreaseRef();

	TInt DecreaseRef();

	void AddSessionL(const CCalSessionImpl& aSession, TInt& aSessionId);

	TBool RemoveSession(const CCalSessionImpl& aSession);

	static RAgendaServ* NewL();

	~RAgendaServ();

	TInt Connect();

	void OpenAgendaL(const CCalSessionImpl& aSession, const TDesC& aFileName, CalCommon::TCalFileVersionSupport& status, TInt64& aFileId, TCalCollectionId& aCollectionId);

	void WaitUntilLoadedL(TCalCollectionId aCalCollectionId);

	void CloseAgenda(TInt aSessionId);

	// Server Utility functions

	void CommitL(TCalCollectionId aCalCollectionId);

	void Rollback(TCalCollectionId aCalCollectionId);

	// Entry / Date Iterator functions

	TBool CreateEntryIteratorL(TInt64 aFileId);

	TBool EntryIteratorNextL(TInt64 aFileId);

	CAgnEntry* FetchEntryByIteratorL(TInt64 aFileId);

	void FindInstancesL(RArray<TInt64>& aCalCollectionIds, CArrayFix<TAgnInstance>& aInstances, const TFindInstanceParams& aParams);

	void FetchFileHandleL(RFile& aFileHandle, TUint32 aAttachmentUid, TInt64 aFileId);

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

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

	CAgnAttachment* FetchAttachmentByIdL(TUint32 aAttachUid, TInt64 aFileId);

	// new connectivity sync functionality

	void GetEntryUidsSinceDateL(RArray<TCalLocalUid>& aUids, const TTime& aFilter, TInt64 aFileId);

	TInt _DebugRequestAllocatedCellsL();		

	void _DebugSetHeapFailL(TInt aHeapAllocationFailureFlag, TInt aCount);

	TInt _DebugRequestAllocatedHeapSizeL();		

public:

	TVersion Version() const;

	// Entry Fetch / Update functions

	CAgnEntry* FetchEntryL(TAgnEntryId& aId, TInt64 aFileId) const;

	CAgnEntry* FetchEntryL(TCalLocalUid aId, TInt64 aFileId) const;

	CAgnSimpleEntry* GetSimpleEntryL(const TAgnEntryId& aId, TCalCollectionId aCalCollectionId) const;

	CAgnSimpleEntry* GetSimpleEntryL(TCalCollectionId aShortFileId, TUint32 aId) const;

	void GetSimpleEntryL(const RArray<TAgnInstance>& aEntryIds, RPointerArray<CAgnSimpleEntry>& aLiteEntries) const;

	void UpdateEntryL(CAgnEntry& aEntry, TBool aDeleteChildren, TCalCollectionId aCalCollectionId);

	TAgnEntryId AddEntryL(CAgnEntry& aEntry, TInt64 aFileId);

	// Model Utility functions

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

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

	HBufC* RestoreTextL(TStreamId aId, TInt64 aFileId);

	TStreamId StoreAlarmActionL(const CAgnContent& aAlarmAction);

	CAgnContent* RestoreAlarmActionL(TStreamId aId, TInt64 aFileId);

	void StartBuildIndex(TBool aNeedProgressReport,TRequestStatus& aStatus, TCalCollectionId aCalCollectionId);

	void StartTidyByDateL(TBool aReportProgress, TRequestStatus& aStatus,

						  const TAgnFilter& aFilter,

						  const TTime& aTodaysDate,

						  const CalCommon::TCalTimeRange& aCalTimeRange,

						  TCalCollectionId aCalCollectionId);	

	void CreateAgendaFileL(const TDesC& aFileName);

	void DeleteAgendaFileL(const TDesC& aFileName, TInt aSessionId);

	CDesCArray* ListAgendaFilesL();

	TBool AgendaFileExistsL(const TDesC& aFileName);

	void RequestProgress(TRequestStatus& aStatus, TCalCollectionId aCalCollectionId);

public:		// category access

	TInt CategoryCountL(TInt64 aFileId);

	CAgnCategory* CategoryL(TInt aIndex, TInt64 aFileId);

	void AddCategoryToListL(const TDesC& aName, TInt64 aFileId);

	void FilterCategoryL(CArrayFixSeg<TAgnEntryId>& aEntries, TInt64 aFileId);

	void CancelTask(TInt64 aFileId);

	void StartCategoryTaskL(TBool aReportProgress, TRequestStatus& aStatus,const CAgnCategory& aCategory, CCalAsyncTaskManager::TAsyncAction aTask, TCalCollectionId aCalCollectionId);

	void FilterCategorySynchronouslyL(const CAgnCategory& aCategory, TCalCollectionId aCalCollectionId);

	// Request notification of any change made to the agenda model.

	void SetChangeNotificationParametersL(MCalChangeCallBack2::TChangeEntryType aEntryType,

								   TBool aIncludeUndatedTodos,

								   TTime aFilterStartTimeUtc,

								   TTime aFilterEndTimeUtc,

								   TInt64 aFileId);

	void RequestChangeNotification(TRequestStatus& aStatus, TInt aSessionId, TUint8 aNotificaitonType);

	void CancelChangeNotification(TInt aSessionId, TUint8 aNotificaitonType);

	void DisableChangeBroadcast(TInt64 aFileId);

	void EnableChangeBroadcast(TInt64 aFileId);

	void GetChangesSinceLastNotificationL(RArray<TCalChangeEntry>& aChangeItems,TCalCollectionId aCalCollectionId, TCalFileId& aFileId);

	void GetFileChangesSinceLastNotificationL(RPointerArray<CAgnFileChangeInfo>& aAgnFileChangeInfo, TInt aSessionId);

	void SetEnablePubSubNotificationsL(TBool aEnablePubSubNotifacation, TInt64 aFileId);

	TInt SetUpdateAlarm(TBool aUpdateAlarm, TInt64 aFileId);

	void DeleteEntryL(TAgnEntryId aEntryId, TCalCollectionId aCalCollectionId);

	void FetchEntryByGuidL(const TDesC8& aGuid, RPointerArray<CAgnEntry>& aList, TInt64 aFileId) const;

	void FetchSimpleEntriesByGuidL(const TDesC8& aUid, RPointerArray<CAgnSimpleEntry>& aLiteEntries, RArray<TInt> aCalCollectionIds) const;

	void DeleteEntryL(const RArray<TCalLocalUid>& aIds, TCalCollectionId aCalCollectionId);

	void DeleteEntryByGuidL(const TDesC8& aGuid, TBool aCommitAndNotify,TInt64 aFileId);

	TTime TzRulesLastModifiedDateL(TInt64 aFileId);

	void DeleteSimpleEntry(CAgnSimpleEntry* aSimpleEntry);

	CAgnSimpleEntry* CreateDumySimpleEntryL();

	CAgnSimpleEntryAllocator& SimpleEntryAllocator() const;

public:

	void __dbgClearTzClientCacheL(TBool aRestartCaching);

public: //Methods for CCalSortedInstanceIterator

#ifdef SYMBIAN_CALENDAR_ENHANCEDSEARCHANDSORT

	TInt CreateInstanceIteratorL(const TFindInstanceParams& aFindParams, const CCalSortCriteria& aSortCriteria,RArray<TInt64>& aCalCollectionIds);

#endif

	void DestroyInstanceIterator(TInt aIteratorId);

	void InstanceIteratorNextL(TInt aIteratorId, CArrayFix<TAgnInstance>& aInstances, TInt aIndex) const;

	void InstanceIteratorPreviousL(TInt aIteratorId, CArrayFix<TAgnInstance>& aInstances, TInt aIndex) const;

	TInt InstanceIteratorCountL(TInt aIteratorId) const; 

	TInt InstanceIteratorLocateIndexL(TInt aIteratorId, TAgnInstance& aInstanceId);

public: // Methods for calendar metadata

    HBufC8* GetPropertyValueL(const TDesC& aFilename, TStreamId aStreamId) const;

    void SetCalendarInfoL(const TDesC& aFilename, const CCalCalendarInfoImpl& aCalendarInfo) const;

    CCalCalendarInfoImpl* GetCalendarInfoLC(const TDesC& aFilename, CCalSessionImpl& aSessionImpl) const;

 private:

	RAgendaServ();	// private constructor

	void ConstructL();

	static TInt StartServer();

	void Panic(TAgnClientPanic aPanic) const;

	TInt DoConnect();

	TInt ServerRequestL(TInt aCommand, TAny* aArg1 = NULL, TAny* aArg2 = NULL, TAny* aArg3 = NULL, TAny* aArg4 = NULL) const;

	CBufFlat* CreateTransmitBufferL(TInt aBufferSize) const;

	void LoadingInstancesFromBufferL(CArrayFix<TAgnInstance>& aInstances, TInt aBufSize) const;

	void ExternalizeFilterL(const TAgnFilter& aFilter, RWriteStream& aStream) const;

	CAgnSimpleEntry* InternalizeSimpleEntryL(RReadStream& aStream) const;

	CAgnEntry* ReadEntryFromServerSessionL(TInt aBufferSize) const;

	CAgnEntry* CreateEntryFromBufferStreamL(RReadStream& readStream) const;

	void SendFileAttachmentHandlesL(CAgnEntry& aEntry, TInt64 aFileId);

	void TransferFileHandleToServerL(TCalLocalUid aLocalUid, TInt aAttachmentIndex, CAgnAttachmentFile& aFileAttachment, TInt64 aFileId);

	void WriteBinaryDataToNewAttachmentFileL(CAgnEntry& aEntry, TInt aAttachmentIndex, TInt64 aFileId);

	TBool FindSession(const CCalSessionImpl& aSession);

private:

	CBufFlat*					     iBuffer;

	CAgnSimpleEntryAllocator*	     iSimpleEntryAllocator;

	TInt						     iReferenceCount;

	RPointerArray<CCalSessionImpl>   iCalSessions; // Not owned.

	TInt                             iLastSessionId;

	};

/**

This Class is used for cleaning up sortentry when a leave happens,

SortEntry should be deleted using SortEntryAllocator.

Cleanup function DestroyLiteEntry uses an object of this class.

*/

class TCleanSimpleEntry

{

public:

	TCleanSimpleEntry(CAgnSimpleEntry& aSortEntry, CAgnSimpleEntryAllocator& aAlloc);

	CAgnSimpleEntry* GetSimpleEntry();

	CAgnSimpleEntryAllocator& GetSimpleEntryAllocator();

	static void DestroySimpleEntry(TAny* aPtr);	//Cleanup function used to delete sortentry.

private:

	CAgnSimpleEntry& iSimpleEntry;

	CAgnSimpleEntryAllocator& iAlloc;

};

#endif