/*

* 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