/*

* 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 "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:  

*     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