/*

* 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)