/** Copyright (c) 2002-2005 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: * A Client MTM to access MMS notifications in a manual fetch mode.* All this is needed to support new mtm type for Symbian OS messaging* UI components.**/#ifndef MMSNOTIFICATIONCLIENTMTM#define MMSNOTIFICATIONCLIENTMTM// INCLUDES#include <mmsclient.h>// CONSTANTS// MACROS// DATA TYPEStypedef struct { TInt mmboxTotalInBytes; // quota used in mmbox, in bytes TInt mmboxTotalInMessageCount; // quota used in mmbox, number of messages TInt mmboxQuotaInBytes; // quota defined for user's mmbox, in bytes TInt mmboxQuotaInMessageCount; // quota defined for user's mmbox, number of messages TTime date; // date and time when the mmbox is updated TInt error; // error about last mmbox update }TMmboxInfo;// FUNCTION PROTOTYPES// FORWARD DECLARATIONS// CLASS DECLARATION/*** Client Mtm for MMS Notifications**/class CMmsNotificationClientMtm : public CMmsClientMtm { public: // Constructors and destructor IMPORT_C static CMmsNotificationClientMtm* NewL( CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession ); /** * Destructor. */ ~CMmsNotificationClientMtm(); public: // New functions /** * Send current forward entry (has to be current context) * @param aCompletionStatus iStatus member of an active object. * Will be set as completed when the request has finished. * @param aSendingTime time at which the message selection is to be sent * given as local time. If aSending time is zero or in the past, the * message is scheduled to be sent as soon as possible. * Defaults to zero meaning immediate sending. * @return pointer to an operation active object. * If successful, this is an asynchronously completing operation. * In failure, a completed operation with status set to the relevant * error code will be returned. * In case the notification is already in use (there is * an operation ongoing) a completed operation with status set KErrInUse * is returned. * If the entry is reserved, the progress of the completed operation * will contain the id of the related entry that was reserved * The returned completed operation also completes the status of the caller * so there is no difference between the operation completing immediately * with an error or starting and then completing with error. */ virtual CMsvOperation* SendL( TRequestStatus& aCompletionStatus, const TTime aSendingTime = TTime( 0 ) ); /** * Returns possible extension text related to the notification * @return descriptor containing the text extension in the notification * empty descriptor if extension does not exist */ virtual const TPtrC GetExtendedText() const; /** * Lists all MMS Notifications, that have no active operation, * for unfetched messages.<br> * Caller must delete the array when no longer needed.<br> * The notifications have similar format as messages, but they * contain only MMS headers, and no attachments.<br> * Individual fields can be queried the same way as for messages. * @return Array of entry IDs of MMS Notifications. */ virtual CMsvEntrySelection* ListNotificationsL(); /** * DeleteNotificationL deletes selected notifications. * @param aSelection contains list of notifications to be deleted * @param aDeleteType specifies which type of delete operation is done: * -EMmsDeleteNotificationOnly: only notification entry from Inbox is deleted * -EMmsDeleteMMBoxOnly: only corresponding message from network is deleted * -EMmsDeleteBoth: both are deleted * @param aCompletionStatus iStatus member of an active object. * It will be set as completed when the request has finished. * @return pointer to an operation active object. * If successful, this is an asynchronously completing operation. * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* DeleteNotificationL( const CMsvEntrySelection& aSelection, TMmsDeleteOperationType aDeleteType, TRequestStatus& aCompletionStatus ); /** * UnscheduledDeleteNotificationL * EXACTLY SAME AS DeleteNotificationL ABOVE, BUT: * This version performs unscheduled delete meaning that the returned * operation will not complete before the whole operation has been executed. * (Previous version completes as soon as MessageServer has scheduled * the request) */ virtual CMsvOperation* UnscheduledDeleteNotificationL( const CMsvEntrySelection& aSelection, TMmsDeleteOperationType aDeleteType, TRequestStatus& aCompletionStatus ); /** * DeleteAllNotificationsL deletes all the notifications found from Inbox * @param aDeleteType specifies which type of delete operation is done: * -EMmsDeleteNotificationOnly: only notification entry from Inbox is deleted * -EMmsDeleteMMBoxOnly: only corresponding message from network is deleted * -EMmsDeleteBoth: both are deleted * @param aCompletionStatus iStatus member of an active object. * It will be set as completed when the request has finished. * @return pointer to an operation active object. * If successful, this is an asynchronously completing operation. * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* DeleteAllNotificationsL( TMmsDeleteOperationType aDeleteType, TRequestStatus& aCompletionStatus ); /** * DeleteForwardEntryL deletes the given selection of forward entries. * Caller should make sure that all the entries in the selection are: * - either in Outbox or Sent Folder * - forward entry created earlier through this API * Entries that do not meet these requirements, are left untouched. * After the call, current context points to forward entry parent (outbox * or sent folder) * Note: that forward request entries should not be deleted directly e.g. * with CMsvEntry, because of the possible locked notification in Inbox. * This method handles this notification. * @param aSelection contains list of forward entries to be deleted */ virtual void DeleteForwardEntryL( const CMsvEntrySelection& aSelection ); /** * Fetch MMS messages referred by the notification selection * from current MMSC to inbox.<br> * If aSelection is empty, the function leaves. * * If the aSelection contains only entries that are not notifications or * are notifications that are not allowed to start a new operation, * The fetch is not started. The function leaves. * * Only real free notifications are fetched. * No error code is returned, if some of the notifications are not fetched and there are * notifications to be fetched. * * @param aSelection selection of notification entries.<br> * @param aCompletionStatus iStatus member of an active object.<br> * It will be set as completed when the request has finished. * @return pointer to an operation active object.<br> * If successful, this is an asynchronously completing operation.<br> * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* FetchMessagesL( const CMsvEntrySelection& aSelection, TRequestStatus& aCompletionStatus ); /** * MmBoxInfoL gives info about MMBox, if available. * @param aMmboxInfo struct about mmboxInfo * @return * ETrue, if info is available. * EFalse, if info is not available. */ virtual TBool MmboxInfoL( TMmboxInfo& aMmboxInfo ); /** * UpdateMmBoxListL updates the list of notifications available * in the MMBox. * @param aCompletionStatus iStatus member of an active object. * It will be set as completed when the request has finished. * @return pointer to an operation active object. * If successful, this is an asynchronously completing operation. * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* UpdateMmBoxListL( TRequestStatus& aCompletionStatus ); /** * Get the Mmbox folder * @return * Id of the mmbox folder */ virtual TMsvId GetMmboxFolderL(); /** * Get number of MMS Notifications for unfetched messages that * have no active operation.<br> * If the receiving of Multimedia Messages has been turned off, * there may be a number of notifications waiting for processing.<br> * When the receiving of messages is turned on again, the UI may want * to check the number of pending notifications before giving the * "FetchAll" command. * @return Number of MMS notifications waiting for processing */ virtual TInt NotificationCount(); /** * Get the value of application id header if present in the notification. * * @since 3.2 */ virtual const TPtrC GetApplicationId() const; public: // Functions from base classes /** * Creates an entry representing forward request based on * the notification being the current context. * @param aDestination refers to the folder where the entry is created * @param aPartlist NOT USED * @param aCompletionStatus reference to the status of an active object. * This status will be set as completed when the operation completes. * @return Pointer to message server operation (active object). * The progress information provides the id of the created message * when the message has been created in a 8-bit descriptor. * While the operation is in progress the package will contain a null * id (KMsvNullIndexEntryId). If there was an error while creating * the message, then the message will be deleted and the package will * contain null id. */ virtual CMsvOperation* ForwardL( TMsvId aDestination, TMsvPartList aPartList, TRequestStatus& aCompletionStatus ); /** * Not supported. * Implementation of the base class is overriden. */ virtual CMsvOperation* SendL( CMsvEntrySelection& aSelection, TRequestStatus& aCompletionStatus, TTime aSendingTime ); /** * Fetch the multimedia message of the notification from current MMSC to inbox.<br> * @param aId Entry ID of a notification that refers to an * unfetched message. * @param aCompletionStatus iStatus member of an active object.<br> * It will be set as completed when the request has finished. * @return pointer to an operation active object.<br> * If successful, this is an asynchronously completing operation.<br> * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* FetchMessageL( TMsvId aId, TRequestStatus& aCompletionStatus ); /** * Fetch multimedia messages for all notifications that are free to be fetched * in Inbox from current MMSC to inbox.<br> * If the Inbox does not contain any notification, the function leaves. * @param aCompletionStatus iStatus member of an active object.<br> * It will be set as completed when the request has finished. * @aparam aForced indicates if the messages should be fetched regardless * or current mode settings. * ETrue = user initiated fetch, use override * EFalse = event triggered fetch, fetch only if settings allow. * @return pointer to an operation active object.<br> * If successful, this is an asynchronously completing operation.<br> * If failed, this is a completed operation, with status set to * the relevant error code. */ virtual CMsvOperation* FetchAllL( TRequestStatus& aCompletionStatus, TBool aForced = ETrue ); /** * QueryCapability */ virtual TInt QueryCapability( TUid aCapability, TInt& aResponse ); protected: // New functions protected: // Functions from base classes private: /** * By default Symbian OS constructor is private. * @param aRegisteredMtmDll Reference to Mtm Dll registry class * @param aSession Reference to a Message Server session. */ CMmsNotificationClientMtm( CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession ); /** * By default Symbian OS constructor is private. */ void ConstructL(); /** * Creates an entry representing forward request based on * the notification being the current context. * @param aDestination refers to the folder where the entry is created * @return entry id of the created forward request entry */ TMsvId CreateForwardEntryL( const TMsvId aDestination ); /** * ReserveNotificationOperationL * method first tests whether an operation is allowed or not. * If allowed, further operations are not possible * If not allowed, error is returned * @param aNotifId pointing to a notification entry * @param aOperation (fetching, forwarding or deleting) * @return Errorcode: * KErrNone if operation was allowed and is now reserved for * this application * KErrInUse if notification already has an operation ongoing */ TInt ReserveNotificationOperationL( const TMsvId aNotifIf, const TUint32 aOperation ); /** * MarkFreeNotificationsReservedL * reserves notifications * aSelection contains only reserved notifications, others are dropped out. * @param aSelection selection of notification entries * @param aOperation (fetching, forwarding or deleting) * @return */ void MarkFreeNotificationsReservedL( CMsvEntrySelection& aNotifications, const TUint32 aOperation ); /** * check if the notification is free to start a new operation */ TBool FreeNotification( TMsvEntry& aEntry, const TUint32 aOperation ); /** * Reserve the notification */ void MarkNotificationOperationReserved( TMsvEntry& aEntry, const TUint32 aOperation ); /** * Find duplicate notification * @param aParent entry id, under where the duplicate is searched * @param aHeaders the original mms headers, whose duplicate is searched * @param aDuplicate entry id of the found duplicate */ void FindDuplicateNotificationL( TMsvId aParent, CMmsHeaders& aHeaders, TMsvId& aDuplicate); public: // Data protected: // Data private: // Data public: // Friend classes protected: // Friend classes private: // Friend classes };#endif // MMSNOTIFICATIONCLIENTMTM // End of File