/*
* Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
* which accompanies this distribution, and is available
* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
*     Miscellaneous constants needed by MmsEngine and its clients
*     (e.g. MCE and DeviceManagement)
*
*/



#ifndef MMSCONST_H
#define MMSCONST_H

//  INCLUDES
#include <msvuids.h>
#include <msvstd.hrh>
#include <e32std.h>
#include <cmsvrecipientlist.h>

// CONSTANTS

// NOTE: January = 0! 1st day of month = 0!
_LIT( KMmsYear1970String, "19700000:000000.000000" );

// <DEPRECATED>
// This is the resource file that contains factory values
// for error actions (for scheduled sending and receiving)
_LIT(KMmsResourceDriveAndFile, "mmsserver.rsc");
// </DEPRECATED>

_LIT(KMMSNotificationFolder, "MMSNotifications");
_LIT(KMmsMmboxFolder, "MmsMmbox");

// constant for conversion between seconds and microseconds
const TInt KMmsMillion = 1000000;

const TInt KMmsDateBufferLength = 30;

//
// Image size definitions - Not used by MMS engine
// anyone who needs image size constants, should define their own
//
//
// <DEPRECATED>
// 160*120
const TInt KMmsImageSmallWidth = 160;
const TInt KMmsImageSmallHeight = 120;
// 640*480
const TInt KMmsImageLargeWidth = 640;
const TInt KMmsImageLargeHeight = 480;
// Original
const TInt KMmsImageOriginalWidth = KMaxTInt;
const TInt KMmsImageOriginalHeight = KMaxTInt;
// </DEPRECATED>

// This is the extra amount of disk space that will be taken
// up by the index entry when creating new message entries.
// This is a crude estimate. It is defined here as a constant
// to allow it to be made more accurate by changing the value
// in only one place.
const TInt KMmsIndexEntryExtra = 80;

// This is the safety margin for fetching MMS messages.
// There should be at least this much extra disk space
// before a message can be fetched. A new message takes
// more disk space than the amount indicated in the
// notification.
const TInt KMmsDiskSafetyMargin = 25000;

//
// DLL UIDs that might be needed
//
const TUid KUidMmsServerMtm={0x100058DB};
const TUid KUidMmsClientMtm={0x100058DC};
const TUid KUidMmsClientUIMtm={0x100058DD};
const TUid KUidMmsClientUIDataMtm={0x100058DD};
// editor and viewer
const TInt KUidMsgMmsEditor={0x100058DE};
const TInt KUidMsgMmsViewer={0x100058DF};

// message types
const TUid KUidMsgTypeMultimedia={0x100058E1};
const TUid KUidMsvTechnologyGroupMMS={0x100058E2};
const TUid KUidMsgMMSNotification={0x100059C8};

// message subtypes
const TUid KUidMsgSubTypeMmsUpload={0x102072CD};
const TUid KUidMsgSubTypeMmsPostcard={0x102072CE};
const TUid KUidMsgSubTypeMmsAudioMsg={0x1020744F};

//
// Stream UIDs
//
// Globally unique values have been allocated to all streams
// MMS headers
const TUid KUidMmsHeaderStream={0x101FB0ED};
// recipient scheduling info
const TUid KUidMmsRecipientStream={0x101FB0EE};
// Notification or delivery report in binary format
const TUid KUidBinaryNotificationStream={0x101FB0EF};
// element descriptor info, only in notification
const TUid KUidMMsElementDescriptorStream = {0x101FB0F0};
// MMBox headers that can be present in several message PDUs
const TUid KUidMMsMMBoxMessageHeaderStream = {0x101FB0F1};
// MMBox headers that are present in MMBox view request and confirmation only
const TUid KUidMMsMMBoxViewHeadersStream = {0x101FB0F2};
// Extra info (message text) present in extended notification.
const TUid KUidMMsExtendedNotificationStream = {0x101FB0F3};
// Attributes for UI use
const TUid KUidMmsAttributeStream = {0x101FB0F4};
// Application id and return-to application id
const TUid KUidMmsApplicationInfoStream = {0x101FB0F5};
// Reserved for internal use
// This stream contains all kinds of unusual information that is rarely present
// These are not part of an actual message, but control the transactions.
// - recommended retrieval mode
// - recommended retrieval mode text
// - replace or cancel id
// - cancel status
const TUid KUidMmsReserved = {0x101FB0F6};

//
// Log entry event type uid (used unless Symbian allocates an id instead)
//
const TUid KLogMmsEventTypeUid = {0x1000595e};

//-----------------------------------------------
// Flag bits in iMtmData1
// The default value for all bits is 0
//-----------------------------------------------
// Message types stored in iMtmData1
// The message types defined are those that could actually be found
// in message store. Values for transient types are not defined.
const TUint32 KMmsMessageTypeMask =         0x0000000F;
const TUint32 KMmsMessageMSendReq =         0x00000001;
// reserved for future use                  0x00000002;
const TUint32 KMmsMessageMNotificationInd = 0x00000003;
// reserved for future use                  0x00000004;
const TUint32 KMmsMessageMRetrieveConf =    0x00000005;
// reserved for future use                  0x00000006;
const TUint32 KMmsMessageDeliveryInd =      0x00000007;
const TUint32 KMmsMessageReadRecInd =       0x00000008;
const TUint32 KMmsMessageReadOrigInd =      0x00000009;
const TUint32 KMmsMessageForwardReq =       0x0000000A;
// reserved for future use                  0x0000000B;
// reserved for future use                  0x0000000C;
// reserved for future use                  0x0000000D;
// reserved for future use                  0x0000000E;
// This must be the last one to allow some expansion for known types
const TUint32 KMmsMessageUnrecognized =     0x0000000F;

// Message state stored in iMtmData1
const TUint32 KMmsMessageEncrypted =        0x00000010;
const TUint32 KMmsMessageSigned =           0x00000020;
const TUint32 KMmsMessageForwarded =        0x00000040;
const TUint32 KMmsMessageMobileTerminated = 0x00000080;
const TUint32 KMmsMessageEditorOriented =   0x00000100;

// bit to indicate that attribute stream is present in entry
const TUint32 KMmsAttributeStreamPresent =  0x00000200;

// reserved for future use
// 0x00000400
// 0x00000800

// Message type flags
// 1 byte reserved (0x0000F000)
// If no flag is set, message is personal (default)
const TUint32 KMmsMessageClassMask     =    0x0000F000;
const TUint32 KMmsMessageAdvertisement =    0x00001000;
const TUint32 KMmsMessageInformational =    0x00002000;
// two message types can be added (0x00004000 and 0x00008000)

// Some free bits here...
const TUint32 KMmsReservedMtmData1 = 0x00FF0000;

// Bit that indicates if the message contains non-conformant content.
// Default value is 0.
// 0 = Message is conformant, or the content is unknown (created by legacy software)
// 1 = Message is known to contain non-conformant content.
const TUint32 KMmsNonConformantMessage =   0x01000000;

// DRM Status in iMtmData1
// A DRM attachment is corrupted and removed
const TUint32 EMmsDrmCorruptedAttachment =		0x02000000;

// Here is still a gap here: bits 0x0C000000 are free.
// (flags 0x04000000 and 0x08000000)
// Should be reserved for future DRM needs.

// <DEPRECATED>
// Range of bits that indicates that the message has some special content
// that needs some non-standard handling
const TUint32 KMmsSpecialContentMask =  0xF0000000;
// undefined special content reserved for future use:  0x10000000
// Special content is "postcard"
const TUint32 KMmsPostcard =            0x20000000;
// Special content is "upload"
const TUint32 KMmsUpload =              0x40000000;
// undefined special content reserved for future use:  0x80000000
// </DEPRECATED>


//-----------------------------------------------
// Flag bits in iMtmData2
// The default value for all bits is 0
//-----------------------------------------------

// Message notification stuff stored in iMtmData2
// Response already sent to MMSC
// or MMBox item for which notify response will not be sent.
// (fetch acknowledged with M-Acknowledge.ind PDU)
const TUint32 KMmsNotifyResponseSent = 0x00000001;
// undecoded (binary) notification
const TUint32 KMmsNotificationBinary = 0x00000002;

// The following flags are related to notifications that are stored in inbox
// to allow the messages to be fetched manually (not automatically)
// has the message corresponding to this notification expired

// Message corresponding to this notification has expired
// 0 = Message has not expired, 1 = Message has expired
const TUint32 KMmsMessageExpired =     0x00000004;

// <DEPRECATED>
const TUint32 KMmsDeleteAtExpiration = 0x00000008;
// </DEPRECATED>

// Operation mask. The next bits tell which operation is currently in progress.
// When a message is being forwarded or fetched, another simulataneous operation
// is not allowed.
// 0 = no operation
const TUint32 KMmsOperationIdentifier = 0x00000070;

// fetch operation in progress
const TUint32 KMmsOperationFetch =      0x00000010;
// forward operation in progress or finished
const TUint32 KMmsOperationForward =    0x00000020;
// delete operation in progress or finished
const TUint32 KMmsOperationDelete =     0x00000030;
// 0x00000040 - 0x00000070 reserved for future operations

// Operation progress bits (4 bits)

// Is new operation allowed for this notification
// 0 = new operation allowed
// 1 = new operation forbidden
const TUint32 KMmsNewOperationForbidden = 0x00000080;
// Is operation currently ongoing
// 0 = no operation
// 1 = operation ongoing
const TUint32 KMmsOperationOngoing =      0x00000100;
// Has operation finished (and is result available)
// 0 = operation has not finished
// 1 = operation has finished
const TUint32 KMmsOperationFinished =     0x00000200;
// Operation result (if operation has finished)
// 0 = OK
// 1 = error
const TUint32 KMmsOperationResult =       0x00000400;

// Has message been stored to MMBox as result of some operation
// or was it in MMBox originally
// 0 = Message not in MMBox
// 1 = Message stored in MMBox
const TUint32 KMmsStoredInMMBox =         0x00000800;

// 0 = Not applicable
// 1 = Notification received in deferred mode, but response
//     sending was not allowed, and therefore notify-response
//     has not been sent to MMSC
const TUint32 KMmsDeferredButResponseNotSent = 0x00001000;

// This is some special notification that should never be
// moved to inbox in manual mode even if fetching fails.
// 0 = May be moved if needed
// 1 = Do not move to inbox
const TUint32 KMmsDoNotMoveToInbox = 0x00002000;

// The message was addressed to an application
// The message has been successfully fetched and routed to the application
// Even if notification remains in inbox, no operations are allowed except
// delete from phone.
const TUint32 KMmsMessageRoutedToApplication = 0x00004000;

// The following flags are for all message types

// bits reserved for future use
const TUint32 KMmsReservedMtmData2 =      0x000F8000;

// Delivery status bytes, valid only for sent messages
// that have been moved to "Sent" folder.
// If the message has been copied or moved to another folder,
// there is no guarantee that these bits are valid anymore.

const TUint32 KMmsDeliveryStatusMask = 0x00F00000;
// Delivery report was not requested
// If the user specifies that no delivery reports are wanted,
// the message stays in this state forever.
// This status means that no delivery data is available.
const TUint32 KMmsDeliveryStatusNotRequested = 0x00000000;

// If Delivery reports have been requested, the number of
// recipients and received delivery reports is stored in
// iMtmData3

// Delivery status is "pending" when the delivery status of all
// recipients is "pending".
const TUint32 KMmsDeliveryStatusPending = 0x00100000;
// delivery status is "partial" when delivery raport about
// successful delivery has been received from at least one recipient.
const TUint32 KMmsDeliveryStatusPartial = 0x00200000;
// delivery status is "failed" if sending has failed for at least
// one recipient
const TUint32 KMmsDeliveryStatysFailed = 0x00400000;
// delivery status is "delivered" if the status of all
// recipients is delivered
const TUint32 KMmsDeliveryStatysDelivered = 0x00800000;


// bits reserved for UI usage
// MMS engine will not change these bits.
// The default value for these bits will be 0.
const TUint32 KMmsReservedForUI =         0xFF000000;

//-----------------------------------------------
// Flag bits in iMtmData3
// The default value for all bits is 0
//-----------------------------------------------

// These are mask values for ranges of bits to be used as counters
// The shift constants indicate how much the value must be shifted
// right to be used as a number, and how much the number must be
// shifted to left before being stored.

// To examine the value use:
// number = ( iMtmData3 & mask ) >> shift;
// To set the value use:
// iMtmData3 &= ~mask;
// iMtmData3 |= number << shift;

// Retry count mask ( for automatic retries )
// max 15 retries counted
const TUint32 KMmsRetryCountMask =          0x0000000F;
// no shift needed for automatic retry count

// Retry count mask ( for manual retries )
// This is reserved for UI usage.
// max 15 retries counted
const TUint32 KMmsManualRetryCountMask =    0x000000F0;
const TInt KMmsManualRetryCountShift = 4;

// The following three areas are used to keep track of delivery status
// of several recipients. These fields are valid only for messages
// that have been sent and have been moved to sent folder.
// The values are not valid in any other context as it is impossible
// to prevent applications from copying messages behind MMS engine's back.
// MMS engine tries to clear these bits in other places, but there is no
// guarantee of that.

// Total number of recipients
// Max 255 recipients
const TUint32 KMmsSentItemTotalRecipientsMask = 0x0000FF00;
const TInt KMmsSentItemTotalRecipientsShift = 8;

// Number of delivery reports with status "delivered"
// Max 255 delivery reports
const TUint32 KMmsSentItemSuccessfullyDeliveredMask = 0x00FF0000;
const TInt KMmsSentItemSuccessfullyDeliveredShift = 16;

// Number of delivery reports with status "failed"
// Max 255 delivery reports
const TUint32 KMmsSentItemFailedDeliveryMask = 0xFF000000;
const TInt KMmsSentItemFailedDeliveryShift = 24;


// End of MtmData bit definitions
// ------------------------------------------------------

// Unicode BOM
const TUint16 KMmsByteOrderMark = 0xFEFF;
const TUint16 KMmsReversedByteOrderMark = 0xFFFE;

// Maximum iDescription read from text/plain file in terms of characters.
const TInt KMmsMaxDescription = 128;

// WSP assigned numbers
const TInt8 KUidMmsWSPMultiPartMixed = 0x23;
const TInt8 KUidMmsWSPMultiPartRelated = 0x33;

// MMS specific field assignments
// same values used for enum values in internal storage
const TUint8 KMmsMessageClassPersonal = 128;
const TUint8 KMmsMessageClassAdvertisement = 129;
const TUint8 KMmsMessageClassInformational = 130;
const TUint8 KMmsMessageClassAuto = 131;

// X-Mms-Message-Type field
// message types since encaps 1.0
const TUint8 KMmsMessageTypeMSendReq = 128;
const TUint8 KMmsMessageTypeMSendConf = 129;
const TUint8 KMmsMessageTypeMNotificationInd = 130;
const TUint8 KMmsMessageTypeMNotifyRespInd = 131;
const TUint8 KMmsMessageTypeMRetrieveConf = 132;
const TUint8 KMmsMessageTypeAcknowledgeInd = 133;
const TUint8 KMmsMessageTypeDeliveryInd = 134;
// message types since encaps 1.1
const TUint8 KMmsMessageTypeReadRecInd = 135;
const TUint8 KMmsMessageTypeReadOrigInd = 136;
const TUint8 KMmsMessageTypeForwardReq = 137;
const TUint8 KMmsMessageTypeForwardConf = 138;
// message types since encaps 1.2
const TUint8 KMmsMessageTypeMboxStoreReq = 139;
const TUint8 KMmsMessageTypeMboxStoreConf = 140;
const TUint8 KMmsMessageTypeMboxViewReq = 141;
const TUint8 KMmsMessageTypeMboxViewConf = 142;
const TUint8 KMmsMessageTypeMBoxUploadReq = 143;
const TUint8 KMmsMessageTypeMBoxUploadConf = 144;
const TUint8 KMmsMessageTypeMBoxDeleteReq = 145;
const TUint8 KMmsMessageTypeMBoxDeleteConf = 146;
const TUint8 KMmsMessageTypeMBoxDescr = 147;
// message types since encaps 1.3
const TUint8 KMmsMessageTypeDeleteReq = 148;
const TUint8 KMmsMessageTypeDeleteConf = 149;
const TUint8 KMmsMessageTypeCancelReq = 150;
const TUint8 KMmsMessageTypeCancelConf = 151;


// X-Mms-Priority field
const TUint8 KMmsPriorityLow = 128;
const TUint8 KMmsPriorityNormal = 129;
const TUint8 KMmsPriorityHigh = 130;

// All fields with Yes/No value
const TUint8 KMmsYes = 128;
const TUint8 KMmsNo = 129;

// X-Mms-Sender-Visibility field
const TUint8 KMmsSenderHide = 128;
const TUint8 KMmsSenderShow = 129;

// X-Mms-Status field
const TUint8 KMmsMessageStatusExpired = 128;
const TUint8 KMmsMessageStatusRetrieved = 129;
const TUint8 KMmsMessageStatusRejected = 130;
const TUint8 KMmsMessageStatusDeferred = 131;
const TUint8 KMmsMessageStatusUnrecognized = 132;
const TUint8 KMmsMessageStatusIndeterminate = 133;
const TUint8 KMmsMessageStatusForwarded = 134;
const TUint8 KMmsMessageStatusUnreachable = 135;

// X-Mms-Read-Status field
const TUint8 KMmsReadStatusRead = 128;
const TUint8 KMmsReadStatusDeletedWithoutBeingRead = 129;

// X-Mms-Reply-Charging field
const TUint8 KMmsReplyChargingRequested = 128;
const TUint8 KMmsReplyChargingRequestedTextOnly = 129;
const TUint8 KMmsReplyChargingAccepted = 130;
const TUint8 KMmsReplyChargingAcceptedTextOnly = 131;

// field assignments since MMS encapsulation 1.2

// X-Mms-Mbox-Quotas field & // X-Mms-MBox-Totals field
const TUint8 KMmsMessageCountToken = 128;
const TUint8 KMmsMessageSizeToken = 129;

// X-Mms-MM-Flags field
const TUint8 KMmsAddToken = 128;
const TUint8 KMmsRemoveToken = 129;
const TUint8 KMmsFilterToken = 130;

// X-Mms-MM-State field
const TUint8 KMmsDraft = 128;
const TUint8 KMmsSent = 129;
const TUint8 KMmsNew = 130;
const TUint8 KMmsRetrieved = 131;
const TUint8 KMmsForwarded = 132;

// Response status or Retrieve status OK
const TInt KMmsResponseStatusOK = 128;

// field assignments since MMS encapsulation 1.3
// These will be needed when 1.3 version is supported (not yet)

// X-Mms-Cancel-Status field
const TUint8 KMmsCancelRequestSuccessfullyReceived = 128;
const TUint8 KMmsCancelRequestCorrupted = 129;

// X-Mms-Content-Class field
const TUint8 KMmsContentClassText = 128;
const TUint8 KMmsContentClassImageBasic = 129;
const TUint8 KMmsContentClassImageRich = 130;
const TUint8 KMmsContentClassVideoBasic = 131;
const TUint8 KMmsContentClassVideoRich = 132;
const TUint8 KMmsContentClassMegaPixel = 133;
const TUint8 KMmsContentClassContentBasic = 134;
const TUint8 KMmsContentClassContentRich = 135;

// X-Mms-Recommended-Retrieval-mode field
const TUint8 KMmsRecommendedRetrievalModeManual = 128;

// end of field assignments

// All content type strings are in KContentTypeTable
// some are defined here to be used separately
_LIT8( KMmsAny, "*/*" );
_LIT8( KMmsTextPlain, "text/plain" );
_LIT8( KMmsApplicationSmil, "application/smil" );
_LIT8( KMmsUnknownType, "application/octet-stream" );
_LIT8( KMmsMultipartReport, "multipart/report" );

// DRM Content subtypes. CMsvMimeHeaders class saves type and subtype separately
_LIT8( KMmsDrmMessageCT,  "vnd.oma.drm.message" ); // DRM Message
_LIT8( KMmsDrmContentCT,  "vnd.oma.drm.content" ); // DRM Content
_LIT8( KMmsDrmRightsTFCT, "vnd.oma.drm.rights+xml" ); // DRM Rights in textual format
_LIT8( KMmsDrmRightsBFCT, "vnd.oma.drm.rights+wbxml" ); // DRM Rights in binary format
_LIT8( KMmsDrmDcfCT,      "vnd.oma.drm.dcf" ); // DRM Content format for discrete media

// Content type parameters used by Java WMA to specify application id
_LIT8( KMmsJavaApplicationId, "Application-ID" );
_LIT8( KMmsJavaReplyApplicationId, "Reply-To-Application-ID" );

// Assigned numbers for content types
// If new assignments are needed, check numbers from KContentTypeTable
const TUint8 KMmsAssignedAny = 0x00;
const TUint8 KMmsAssignedText = 0x01;
const TUint8 KMmsAssignedTextPlain = 0x03;
const TUint8 KMmsAssignedApplicationVndWapMultipart = 0x22;
const TUint8 KMmsAssignedApplicationVndWapMultipartMixed = 0x23;
const TUint8 KMmsAssignedApplicationVndWapMultipartAlternative = 0x26;
const TUint8 KMmsAssignedApplicationXml = 0x27;
const TUint8 KMmsAssignedApplicationVndWapWbxml = 0x29;
const TUint8 KMmsAssignedApplicationVndWapMultipartRelated = 0x33;

// IANA / WSP numbers for character sets
const TUint8 KMmsUtf8 = 0x6A;
const TUint8 KMmsUsAscii = 0x03;
const TUint KMmsIso10646Ucs2 = 0x03E8; // 1000
const TUint KMmsUTF16 = 0x03F7; // 1015
const TUint KMmsUTF16BE = 0x03F5; // 1013
const TUint KMmsUTF16LE = 0x03F6; // 1014
const TUint KMmsUtf7 = 0x03F4; // 1012

// CR/LF definitions for removal...
_LIT ( KLf16, "\x00A" ); // 16 bit line feed
_LIT ( KCr16, "\x00D" ); // 16 bit carriage return
_LIT ( KSpace16, " " ); // 16 bit space
_LIT ( KEqualsQuestion16, "=?" ); // MIME encoding starter
_LIT ( KQuote16, "\x022" ); // 16 bit quote
_LIT ( KMmsUnicodeLineSeparator, "\x2028");
_LIT ( KMmsUnicodeParagraphSeparator, "\x2029");
_LIT ( KMmsIdeographicSpace, "\x3000");
_LIT8 ( KLf8, "\x00A" ); // 8 bit line feed
_LIT8 ( KCr8, "\x00D" ); // 8 bit carriage return
_LIT8 ( KSpace8, " " ); // 8 bit space
_LIT8 ( KSemicolon8, ";" ); // 8 bit semicolon
_LIT8 ( KEquals8, "=" ); // 8 bit equal
_LIT8 ( KMmsSlash8, "/"); // 8 bit slash
_LIT8 ( KMmsLeftAngle, "<"); // 8 bit angle bracket
_LIT8 ( KMmsRightAngle, ">"); // 8 bit angle bracket

// MACROS

// DATA TYPES

// Possible address types
enum TMmsAddressType
    {
    EMmsAddressTypeUnknown = 0,
    EMmsAddressTypeMobile,
    EMmsAddressTypeEmail,
    EMmsAddressTypeIpv4,
    EMmsAddressTypeIpv6
    };

// These panics should only be used in ASSERT_DEBUGs
// (The user should not see these)
enum TMmsPanic // MMS error codes
    {
    EMmsBadMtmTypeUid = KErrNone+1,
    EMmsNoCMsvEntrySet,
    EMmsEntryTypeNotSupported,
    EMmsHeadersNotFound,
    EMmsAlreadyBusy,
    EMmsUnknownState,
    EMmsActiveInFinalProgress,
    EMmsFinalProgressFailed,
    EMmsNotAMessageEntry
    };


// Values for recipient types
// <DEPRECATED>
// old TMmsRecipients type values should not be used any more!
// instead use TMsvRecipientType values by Symbian!
typedef TMsvRecipientType TMmsRecipients;
#define EMmsTo EMsvRecipientTo
#define EMmsCc EMsvRecipientCc
#define EMmsBcc EMsvRecipientBcc
// </DEPRECATED>

enum TMmsYesNo
    {
    EMmsYes = KMmsYes,
    EMmsNo = KMmsNo
    };

// Values for message Delivery-Report
typedef TMmsYesNo TMmsMessageDeliveryReport;
// Values for Delivery-Report allowed
typedef TMmsYesNo TMmsSettingsDeliveryReportAllowed;
// Values for message Read-Reply
typedef TMmsYesNo TMmsMessageReadReply;
// Values for Read-Reply sending allowed
typedef TMmsYesNo TMmsSettingsReadReplyAllowed;

// <DEPRECATED>
// use EMmsYes and EMmsNo instead
#define EMmsDeliveryReportYes EMmsYes
#define EMmsDeliveryReportNo EMmsNo

#define EMmsDeliveryReportAllowedYes EMmsYes
#define EMmsDeliveryReportAllowedNo EMmsNo

#define EMmsReadReplyYes EMmsYes
#define EMmsReadreplyNo EMmsNo

#define EMmsReadReplyAllowedYes EMmsYes
#define EMmsReadReplyAllowedNo EMmsNo
// </DEPRECATED>

// Values for message class
enum TMmsMessageClass
    {
    EMmsMimimumMessageClass = KMmsMessageClassPersonal,
    EMmsClassPersonal = KMmsMessageClassPersonal,
    EMmsClassAdvertisement = KMmsMessageClassAdvertisement,
    EMmsClassInformational = KMmsMessageClassInformational,
    EMmsClassAuto = KMmsMessageClassAuto,
    // change following if new message classes are added
    EMmsMaximumMessageClass = KMmsMessageClassAuto
    };

// Values for message priority
enum TMmsMessagePriority
    {
    EMmsMinimumPriority = KMmsPriorityLow,
    EMmsPriorityLow = KMmsPriorityLow,
    EMmsPriorityNormal = KMmsPriorityNormal,
    EMmsPriorityHigh = KMmsPriorityHigh,
    // change following if new priorities added
    EMmsMaximumPriority = KMmsPriorityHigh
    };

// Values for message Sender-Visibility
enum TMmsMessageSenderVisibility
    {
    EMmsSenderVisibilityDefault = 0,
    EMmsMinimumSenderVisibility = KMmsSenderHide, // always minimum
    EMmsSenderVisibilityHide = KMmsSenderHide,
    EMmsSenderVisibilityShow = KMmsSenderShow,
    EMmsMaximumSenderVisibility = KMmsSenderShow // change if new values added
    };


// Values for MMS Creation mode
enum TMmsCreationMode
    {
    EMmsCreationModeRestricted = 0,
    EMmsCreationModeWarning = 1,
    EMmsCreationModeFree = 2
    };

// <DEPRECATED>
// Values for Message-Type field
// correspond to binary encoding!
// Message type cannot be set using Client MTM
// Use KMms constants instead.
enum TMmsMessageType
    {
    EMmsMSendReq = KMmsMessageTypeMSendReq,
    EMmsMSendConf = KMmsMessageTypeMSendConf,
    EMmsNotificationInd = KMmsMessageTypeMNotificationInd,
    EMmsNotifyRespInd = KMmsMessageTypeMNotifyRespInd,
    EMmsRetrieveConf = KMmsMessageTypeMRetrieveConf,
    EMmsAcknowledgeInd = KMmsMessageTypeAcknowledgeInd,
    EMmsDeliveryInd = KMmsMessageTypeDeliveryInd,
    EMmsReadRecInd = KMmsMessageTypeReadRecInd,
    EMmsReadOrigInd = KMmsMessageTypeReadOrigInd,
    EMmsForwardReq = KMmsMessageTypeForwardReq,
    EMmsForwardConf = KMmsMessageTypeForwardConf
    };
// </DEPRECATED>


// <DEPRECATED>
// Values for Status field
// correspond to binary encoding!
// Use KMms constants instead.
enum TMmsMessageStatus
    {
    EMmsStatusExpired = KMmsMessageStatusExpired,
    EMmsStatusRetrieved = KMmsMessageStatusRetrieved,
    EMmsStatusRejected = KMmsMessageStatusRejected,
    EMmsStatusDeferred = KMmsMessageStatusDeferred,
    EMmsStatusUnrecognized = KMmsMessageStatusUnrecognized,
    EMmsStatusIndeterminate = KMmsMessageStatusIndeterminate,
    EMmsStatusForwarded = KMmsMessageStatusForwarded,
    EMmsStatusUnreachable = KMmsMessageStatusUnreachable
    };
// </DEPRECATED>

// Values for read status
// correspond to binary encoding!
enum TMmsReadStatus
    {
    EMmsReadStatusRead = KMmsReadStatusRead,
    EMmsReadStatusDeletedWithoutBeingRead = KMmsReadStatusDeletedWithoutBeingRead
    };

enum TMmsReplyCharging
    {
    EMmsReplyChargingRequested = KMmsReplyChargingRequested,
    EMmsReplyChargingRequestedTextOnly = KMmsReplyChargingRequestedTextOnly,
    EMmsReplyChargingAccepted = KMmsReplyChargingAccepted,
    EMmsReplyChargingAcceptedTextOnly = KMmsReplyChargingAcceptedTextOnly
    };

// mms receiving mode
enum TMmsReceivingMode
    {
    EMmsReceivingMin = 1,
    EMmsReceivingAutomatic = EMmsReceivingMin,
    EMmsReceivingManual = EMmsReceivingMin + 1,
    EMmsReceivingPostpone = EMmsReceivingManual + 1,
    EMmsReceivingReject = EMmsReceivingPostpone + 1,
    EMmsReceivingMax = EMmsReceivingReject
    };

// Factory settings
enum TMmsFactorySettingsLevel
    {
    EMmsFactorySettingsLevelNormal = 0x0,
    EMmsFactorySettingsLevelDeep
    };

// Type of the Delete operation
enum TMmsDeleteOperationType
    {
    EMmsDeleteNotificationOnly,
    EMmsDeleteMMBoxOnly,
    EMmsDeleteBoth
    };

#endif      // MMSCONST_H

// End of File
