// Copyright (c) 1998-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://#if !defined(__MSVIPC_H__)#define __MSVIPC_H__#if !defined(__E32BASE_H__)#include <e32base.h>#endif#if !defined(__MSVSTD_H__)#include <msvstd.h>#endif#if !defined(__MSVSEARCHSORTQUERY_H__)#include <msvsearchsortquery.h>#endif//const TInt KMsvNullOperation=0;const TInt KMsvFirstOperation=1;//const TInt KMsvSessionBufferLength=0x1000;const TInt KMsvProgressBufferLength=256;struct TMsvIdWithSortField;// ***** NOTE!!!!! TMsvPackedChangeNotification::UnpackL() MUST be ****// ***** updated when adding new types *****/**@internalComponent@released*/enum TMsvServerChangeNotificationType { EMsvNullNotification=-1, EMsvEntriesNoChange=0, EMsvEntriesCreated=1, EMsvEntriesChanged=2, EMsvEntriesDeleted=3, EMsvEntriesMoved=4, EMsvMtmGroupInstalled=5, EMsvMtmGroupDeInstalled=6, EMsvStoreDeleted=7, EMsvCloseSession=8, EMsvIndexLoaded=9, EMsvIndexFailedToLoad=10, EMsvMediaChanged=12, // Note: I assume the following four follow each other in order EMsvMediaUnavailable=13, EMsvMediaAvailable=14, EMsvMediaIncorrect=15,#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT) EMsvMessageStoreNotSupported=16, EMsvMessageStoreCorrupt=17, EMsvRefreshMessageView=18, EMsvDiskNotAvailable=19, EMsvUnableToProcessDiskNotification=20#endif };//**********************************// TMsvPackedEntry//**********************************//// Packs a TMsvEntry and the two associated descriptors into a buffer for// sending across IPC. Also unpacks the data into a TMsvEntry and two heap // descriptors////class TMsvEntry;class TMsvPackedEntry/**@internalComponent@released*/ {public: IMPORT_C TMsvPackedEntry(HBufC8*& aBuffer); IMPORT_C TInt PackEntry(const TMsvEntry& aEntry); IMPORT_C void UnpackEntry(TMsvEntry& aEntry);private: HBufC8*& iBuffer; };//**********************************// TMsvPackedEntryArray//**********************************//// Packs 1+ TMsvEntry's and the associated descriptors into a buffer for// sending across IPC. Also unpacks the data into a TMsvEntry and two heap // descriptors using indexed access////class TMsvPackedEntryArray/**@internalComponent@released*/ {public: IMPORT_C TMsvPackedEntryArray(HBufC8*& aBuffer, TInt aCount=0); IMPORT_C TInt PackEntry(const TMsvEntry& aEntry); IMPORT_C TInt UnpackEntry(TInt aEntryIndex, TMsvEntry& aEntry); IMPORT_C void Reset();private: TInt FindEntryInArray(TInt aIndex);private: TInt iIndex; TInt iCount; const TUint8* iPos; HBufC8*& iBuffer; };//**********************************// TMsvChildrenDetails//**********************************//// Contains the information about the number of children of an entry and how many// have been sent in the main buffer//class TMsvChildrenDetails/**@internalComponent@released*/ {public: IMPORT_C TMsvChildrenDetails();public: TMsvId iParentId; TInt iTotalNumberChildren; TInt iNumberChildrenInArray; TInt iLastEntryInArray; };//**********************************// TMsvLocalOperationProgress//**********************************//// Contains the information about a local operation//class TMsvLocalOperationProgress/** Encapsulates progress information returned by a local operation. A local operation is a CMsvOperation-derived object returned by a function that affects only local entries. For example, such a function would be a CMsvEntry::ChangeL() call on a local entry. You can check if the operation is local from CMsvOperation::Mtm(): a local operation returns a value of KUidMsvLocalServiceMtm. Progress information is obtained, in a packaged format, by calling CMsvOperation::ProgressL(). Understanding the TMsvLocalOperationProgress structure enables an application to use that information for a local operation. @publishedAll@released*/ {public:/** Defines the possible values for the type of operation progress report. @publishedAll@released*/ enum TLocalOperation { /** Default value for new TMsvLocalOperationProgress */ ELocalNone=0, /** Move operation */ ELocalMove, /** Delete operation */ ELocalDelete, /** Copy operation */ ELocalCopy, /** Create operation */ ELocalNew, /** Change operation */ ELocalChanged };public: IMPORT_C TMsvLocalOperationProgress();public: /** The type of operation on which the progress is reporting */ TLocalOperation iType; /** The number of entries on which the operation was or will be attempted */ TInt iTotalNumberOfEntries; /** The number of entries on which the operation has been successful */ TInt iNumberCompleted; /** The number of entries on which the operation has failed */ TInt iNumberFailed; /** The number of entries on which the operation has yet to be attempted */ TInt iNumberRemaining; /** The error code for the latest failed operation */ TInt iError; /** This contains different information for different operation types: 1. copying a single entry: ID of the new entry 2. moving an entry: ID of the entry moved 3. copying or moving multiple entries: ID of the first entry in the selection */ TMsvId iId; };//**********************************// TMsvServerOperationProgress//**********************************/** Encapsulates progress information returned by a non-MTM specific Message Server operation. You can check if an operation has this type of progress information by calling CMsvOperation::Mtm(): a suitable operation returns a value of KUidMsvServerMtm. Progress information is obtained, in a packaged format, by calling CMsvOperation::ProgressL(). Understanding the TMsvServerOperationProgress class enables an application to use that information for a Message Server operation. @see TMsvLocalOperationProgress @see CMsvSession::CopyStoreL() @see CMsvSession::DeleteStoreL()@publishedAll@released*/class TMsvServerOperationProgress {public: enum TMsvServerOperationType { /** No operation in progress. */ EMsvNoOperation = 0, /** Change drive operation in progress. @see CMsvSession::ChangeDriveL() */ EMsvChangeDriveOperation , /** Copy Store operation in progress. @see CMsvSession::CopyStoreL() */ EMsvCopyOperation, /** Delete Store operation in progress. @see CMsvSession::DeleteStoreL() */ EMsvDeleteOperation }; //public: IMPORT_C TMsvServerOperationProgress(); TMsvServerOperationProgress(TMsvServerOperationType aType); //public: /** The type of operation in progress. */ TMsvServerOperationType iOperationType; };//**********************************// TMsvIndexProgress//**********************************class TMsvIndexProgress/** Provides details of index loading progress. @see TMsvIndexLoadProgress @publishedAll@released*/ {public: IMPORT_C TMsvIndexProgress(); //public: /** Total number of entries in the index. */ TInt iTotal; /** Number of entries created so far. */ TInt iCompleted; /** Number of entries remaining. */ TInt iRemaining; /** ID of entry last created. */ TMsvId iId; };//**********************************// TMsvIndexLoadProgress//**********************************class TMsvIndexLoadProgress : public TMsvServerOperationProgress/** Progress information for an operation controlling the Message Server loading its index. Such an operation can occur when the Message Server changes drive.@see CMsvOperation@see CMsvSession::ChangeDriveL() @publishedAll@released*/ {public: /** States for the index loading process. @publishedAll@released*/ enum TIndexState { /** Index loading has not begun. */ EIndexNotLoaded = 0, /** Index loading is in progress. */ EIndexLoading, /** Index is being built. */ EIndexRebuilding, /** Index loading is complete. */ EIndexComplete}; //public: IMPORT_C TMsvIndexLoadProgress(); //public: /** Stores any errors that prevented the index being loaded. */ TInt iError; /** Current state of the index loading process. */ TIndexState iState; /** Details of the index loading progress. */ TMsvIndexProgress iIndex; };//**********************************// TMsvCopyProgress//**********************************/** Progress information for the copy operation. @see CMsvOperation@see CMsvSession::CopyStoreL() @publishedAll@released*/class TMsvCopyProgress : public TMsvServerOperationProgress {public:/** States for the copy operation. @publishedAll@released*/ enum TCopyState { /** Operation not yet started */ ENotYetStarted = 0, /** Mail Store is being locked */ ELock, /** Initialising Copy operation */ EInitCopy, /** Mail Store is being copied */ ECopyStore, /** Mail Store is being unlocked. */ EUnlock, /** Operation completed */ ECompleted }; /** Stores any errors that the operation encountered. */ TInt iError; TInt iTotal; // Total number of items to be copied TInt iCurrent; // Current item number being copied TCopyState iState;public: IMPORT_C TMsvCopyProgress(); };//**********************************// TMsvDeleteProgress//**********************************/** Progress information for the delete operation.@see CMsvOperation@see CMsvSession::DeleteStoreL() @publishedAll@released*/class TMsvDeleteProgress : public TMsvServerOperationProgress {public:/** States for the delete operation. @publishedAll@released*/ enum TDeleteState { /** Operation not yet started */ ENotYetStarted = 0, /** Mail Store is being deleted */ EDeleteStore, /** Operation is complete */ ECompleted }; /** Stores any errors that the operation encountered. */ TInt iError; TDeleteState iState;public: IMPORT_C TMsvDeleteProgress(); };//**********************************// TMsvPackedOperation//**********************************//// Packs an operation, the selection, and some associated parameters (TInt) into the// IPC buffer////class TMsvPackedOperation/**@internalComponent@released*/ {public: IMPORT_C TMsvPackedOperation(HBufC8*& aBuffer); IMPORT_C TInt Pack(const CMsvEntrySelection& aSelection, TInt aParameter1=0, TInt aParameter2=0); IMPORT_C void UnpackL(CMsvEntrySelection& aSelection, TInt& aParameter1, TInt& aParameter2);private: HBufC8*& iBuffer; };//**********************************// TMsvPackedChangeNotification//**********************************//// Packs the CMsvEntrySelection of index entries that have been changed, and also // the integer describing the type of change. There is a limit of KMsvPackedChangeLimit// top the number of entry ids that can be sent at one time////typedef TBuf8<128> TMsvNotifBuffer;class TMsvPackedChangeNotification/**@internalComponent@released*/ {public: enum { KMsvChangeNotificationNumberOfTInts=4, KMsvPackedChangeLimit=28, // 32-KMsvChangeNotificationNumberOfTInts }; public: IMPORT_C TMsvPackedChangeNotification(TMsvNotifBuffer& aBuffer); inline void Pack(TMsvServerChangeNotificationType aChangeType, const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2); IMPORT_C void Pack(TMsvServerChangeNotificationType aChangeType, const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2, TInt aStartIndex, TInt aFinishIndex); IMPORT_C void Pack(TMsvServerChangeNotificationType aChangeType, TMsvId aId, TInt aParameter1, TInt aParameter2); IMPORT_C void UnpackL(TMsvServerChangeNotificationType& aChangeType, CMsvEntrySelection& aSelection, TInt& aParameter1, TInt& aParameter2);private: TMsvNotifBuffer& iBuffer; };//**********************************// TMsvPackedEntryFilter//**********************************class TMsvPackedEntryFilter/**@internalComponent@released*/ {public: TMsvPackedEntryFilter(HBufC8*& aBuffer); TInt PackFilter(const CMsvEntryFilter& aFilter); void UnpackFilter(CMsvEntryFilter& aFilter);private: HBufC8*& iBuffer; };/**Packs TMsvSearchSortQuery object into a buffer for sending across IPC. Also unpacks the buffer to TMsvSearchSortQuery@internalComponent@released*/class TMsvPackQuery {public: IMPORT_C TMsvPackQuery(HBufC8*& aBuffer); IMPORT_C TInt PackQuery(const CMsvSearchSortQuery* aQuery); IMPORT_C void UnpackQuery(CMsvSearchSortQuery* aQuery);private: TInt DoPackQuery(const TUint8*& aPtrStart, const TUint8* aPtrEnd, const CMsvSearchSortQuery* aQuery); void DoUnpackQuery(TUint8*& aPtr, CMsvSearchSortQuery* aQuery);private: HBufC8*& iBuffer; };/**Packs RArray of TMsvId into a buffer for sending across IPC. Also unpacks the TMsvId's to RArray@internalComponent@released*/class TMsvPackedIdOperation {public: IMPORT_C TMsvPackedIdOperation(HBufC8*& aBuffer); IMPORT_C TInt Pack(const RArray<TMsvId>& aId); IMPORT_C void UnpackL(RArray<TMsvId>& aId);private: HBufC8*& iBuffer; };/**Packs RArray of TMsvId with Sort field into a buffer for sending across IPC. Also unpacks the TMsvId and Sort filed to RArray@internalComponent@released*/class TMsvPackedIdAndMessagePart {public: IMPORT_C TMsvPackedIdAndMessagePart(); IMPORT_C TInt Size(const RArray<TMsvIdWithSortField>& aData); IMPORT_C void ExternalizeL(RWriteStream& aWriteStream, RArray<TMsvIdWithSortField>& aData) const; IMPORT_C void InternalizeL(RReadStream& aReadStream, RArray<TMsvIdWithSortField>& aData); };#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)/**@internalComponent@released*/class TMsvPackedDriveIdOperation {public: IMPORT_C TMsvPackedDriveIdOperation(HBufC8*& aBuffer); IMPORT_C TInt Pack(const RArray<TDriveNumber>& aDriveNumber); IMPORT_C void UnpackL(RArray<TDriveNumber>& aDriveNumber);private: HBufC8*& iBuffer; };#endif // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)/** * Pack unpack the header structure from a buffer * @internalComponent * @released */class TMsvPackedHeaderStructure {public: IMPORT_C TMsvPackedHeaderStructure(HBufC8*& aBuffer); IMPORT_C TInt Pack(const RPointerArray<CFieldPair>& aFieldDetails); IMPORT_C void UnpackL(RPointerArray<CFieldPair>& aFieldDetails);private: HBufC8*& iBuffer; };/** * Pack unpack the header data from a buffer * @internalComponent * @released */class TMsvPackedHeaderData {public: IMPORT_C TMsvPackedHeaderData(HBufC8*& aBuffer); IMPORT_C TInt Pack(const RPointerArray<CHeaderFields>& aFieldDetails); IMPORT_C void UnpackL(RPointerArray<CHeaderFields>& aFieldDetails);private: HBufC8*& iBuffer; };#endif // #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)#include <msvipc.inl>#endif