// Copyright (c) 1999-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:

 // CACHEMAN.H

 //

 /**

  * @file 

  * @publishedAll

  * @released

  */

 #if !defined (__CACHEMAN_H__)

 #define __CACHEMAN_H__

 #include <mentact.h>

 #include <msvstd.h>

 #include <msvapi.h>

 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS  

 #include <cimprunemessage.h>

 #include "cimfinder.h"

 #endif

 class CImMessageFinder;

 class CImMessageCounter;

 struct TImCacheManagerProgress

 /** Holds progress of a cache management cleanup operation.

 @see CImCacheManager::ProgressL() 

 @publishedAll

 @released

 */

 	{

 public:

 	/** Total number of messages to process.

 	Note that, immediately after a CImCacheManager object is started, the progress 

 	operation may return 1 for iTotalMessages and 0 for iMessagesProcessed, regardless 

 	of the total number of messages. This is because the counter for the iTotalMessages 

 	operates asynchronously and may not have counted all of the messages at that 

 	time. */

 	TInt iTotalMessages;

 	/** Number of messages processed so far. */

 	TInt iMessagesProcessed;

 	};

 class CImCacheManager : public CMsvOperation

 /** Provides management of the local cache of messages in remote mailboxes.

 A mailbox that is being used in disconnected mode allows the user access to 

 message data by opening the message directly from the remote mailbox. If the 

 required message has been downloaded previously, then it will not necessarily 

 need to be downloaded again. This functionality is achieved by preserving 

 the message data locally, under the remote service entry. The preserved message 

 data acts as a cache to allow the user access to the message without the need 

 for it to be downloaded every time. 

 The cache management functionality is required to reduce the amount of memory 

 that is consumed by the message cache. CImCacheManager provides a mechanism 

 for asynchronously traversing a message tree and for removing text and attachment 

 data from messages. Deleting more message data will free up more memory but 

 there is a higher chance that a user will need to download a message for a 

 second time. 

 CImCacheManager is an abstract base class, which can be specialised to implement 

 a filter (Filter()) that decides if data for a message shoulded be deleted: 

 for example, deletion could be restricted to 'all read messages over a week 

 old,' or, 'all read messages, over 20K in size which are also over a day old.' 

 @publishedAll

 @released

 */

 	{

 public:

 	IMPORT_C void StartL(TMsvId aRootEntry, TRequestStatus &aStatus);

 	IMPORT_C void StartL(const CMsvEntrySelection& aSelection, TRequestStatus &aStatus);

 	IMPORT_C ~CImCacheManager();

 	IMPORT_C const TDesC8& ProgressL();

 	IMPORT_C void DoCancel();

 protected:

 	IMPORT_C void ConstructL();

 	IMPORT_C CImCacheManager(CMsvSession& aSession, TRequestStatus& aObserverRequestStatus);

 	IMPORT_C void RunL();

 private:

 	// Override this function to filter the currently selected message (iCurrentEntry).

 	// Return TRUE if the current entry is to be pruned.

 	/** Tests if cache cleanup should be performed on a message entry.

 	After StartL() has been called, this is called once for each message entry. 

 	It should return true if the body text and attachment data belonging to the 

 	current message, as held in iCurrentEntry, should be deleted, or false if 

 	the message should be left unchanged.

 	This function must be implemented in any classes derived from CImCacheManager.

 	@return True to clean the entry, false to leave it unchanged */

 	virtual TBool Filter() const = 0;

 	void DoRunL();

 	// Remove the store from the currently selected entry

 	inline void PruneMessageL();

 protected:

 	/** Message entry currently being processed. */

 	CMsvEntry* iCurrentEntry;

 private:

 	CMsvSession& iSession;

 	CImMessageFinder* iMessageFinder;

 	CImMessageCounter* iMessageCounter;

 	CMsvOperation* iDeleteOperation;

 	TImCacheManagerProgress iProgress;

 	TRequestStatus* iReport;

 	enum TImcmState

 		{

 		EImcmLookingForMessage,

 		EImcmPruningMessages,

 		EImcmCountingMessages,

 		EImcmSkippingPrune

 		};

 	TMsvId iRootEntry;

 	TImcmState iState;

 	TPckgBuf<TImCacheManagerProgress> iProgressBuf;

 	CMsvEntrySelection* iMessagesToPrune;

 	};

 #endif