/*
* 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 TYPES
typedef 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 overridden.
*/
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