1 /*

     2 * Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: mmsheaders  declaration

    15 *

    16 */

    17 

    18 

    19  

    20 #ifndef CMMSHEADERS_H

    21 #define CMMSHEADERS_H

    22 

    23 //  INCLUDES

    24 #include <e32base.h>

    25 #include <badesca.h>

    26 #include <mtclbase.h>       // TMsvPartList

    27 #include "mmsconst.h"

    28 #include "mmsgenutils.h"

    29 #include "mmssendingchain.h"

    30 #include "mmsdeleteresultarray.h"

    31 

    32 // CONSTANTS

    33 // Maximum size for Multimedia message field string value.

    34 const TInt KMaxHeaderStringLength = 1000;

    35 

    36 // MACROS

    37 

    38 // DATA TYPES

    39 

    40 // FUNCTION PROTOTYPES

    41 

    42 // FORWARD DECLARATIONS

    43 class CMmsSettings;

    44 class CMmsElementDescriptor;

    45 class CMmsMMBoxMessageHeaders;

    46 class CMmsMMBoxViewHeaders;

    47 

    48 // CLASS DECLARATION

    49 

    50 /**

    51 *  This class provides access to MMS specific header data.

    52 *  The class can be used from both Client MTM and Server MTM.

    53 */

    54 class CMmsHeaders:public CBase

    55     {

    56     public:  // Constructors and destructor

    57         

    58 // <DEPRECATED>

    59         /**

    60         * Two-phased constructor.

    61         * This is a legacy function and sets the default mms version

    62         * to a hard coded value.

    63         * All client should use the NewL version that gives the version

    64         * as parameter. The version value should come form CMmsSettings class

    65         */

    66         IMPORT_C static CMmsHeaders* NewL();

    67 // </DEPRECATED>

    68         

    69         /**

    70         * Two-phased constructor.

    71         * @param aMmsVersion The version of MMS encapsulation that should be

    72         *     used unless the actual message contains some other value

    73         */

    74         IMPORT_C static CMmsHeaders* NewL( TInt16 aMmsVersion );

    75         

    76         /**

    77         * Destructor.

    78         */

    79         virtual ~CMmsHeaders();

    80 

    81     public: // New functions

    82         

    83         /**

    84         * Reset.

    85         * @param aSettings MMS settings to be used for initial values. Can be NULL.

    86         */

    87         IMPORT_C void Reset( CMmsSettings* aSettings = NULL);

    88 

    89         /**

    90         * Internalize the headers.

    91         * @param aStore CMsvStore

    92         */

    93         IMPORT_C void RestoreL( CMsvStore& aStore );

    94 

    95         /**

    96         * Externalize the headers.

    97         * Caller must commit the store to allow several store operations

    98         *     before committing the store

    99         * @param aStore CMsvStore in edit mode.

   100         */

   101         IMPORT_C void StoreL( CMsvStore& aStore );

   102 

   103         /**

   104         * Subject mutator. Note that Client MTM should update explicitly 

   105         * TMsvEntry.iDescription too.

   106         * @param aSubject subject string,

   107         */

   108         IMPORT_C void SetSubjectL( const TDesC& aSubject );

   109 

   110         /**

   111         * Subject accessor.

   112         * @return Subject string.

   113         */

   114         IMPORT_C TPtrC Subject() const;

   115 

   116         /**

   117         * Returns recipients that are of specified type (To, Cc, Bcc).

   118         * @param aType specifies recipient type (types defined in MMSCONST.H)

   119         * @return array of recipient addresses.

   120         */

   121         IMPORT_C const CDesCArray& TypedAddresseeList( TMmsRecipients aType );

   122 

   123         /**

   124         * Adds recipient with specified type (To, Cc, Bcc).<br>

   125         * This function also adds all recipients into the internal list <br>

   126         * that contains all addressees regardless of addressee type.<br>

   127         * @param aRealAddress recipient address.

   128         * @param aType specifies recipient type (types defined in MMSCONST.H)

   129         */

   130         IMPORT_C void AddTypedAddresseeL( const TDesC& aRealAddress, 

   131                                           TMmsRecipients aType );

   132 

   133         /**

   134         * Remove a given address from the right typed list.

   135         * @param aRealAddress recipient address.

   136         * @return ETrue is address is found and deleted.

   137         */

   138         IMPORT_C TBool RemoveAddressee( const TDesC& aRealAddress );

   139 

   140         /**

   141         * Sender mutator

   142         * @param aAlias

   143         */

   144         IMPORT_C void SetSenderL( const TDesC& aAlias );

   145 

   146         /**

   147         * Sender accessor

   148         * @return Real address of sender (for example phone number). <br>

   149         *     Alias can be searched from contacts database.

   150         */

   151         IMPORT_C TPtrC Sender() const;

   152 

   153         /**

   154         * Message class accessor

   155         * @return Message class: Personal/Advertisement/Informational. <br>

   156         *     values defined in MMSCONST.H

   157         */

   158         inline TInt MessageClass() const;

   159 

   160         /**

   161         * Message class mutator

   162         * values defined in MMSCONST.H

   163         */

   164         inline void SetMessageClass( TInt aClass );

   165 

   166         /**

   167         * Expiration interval mutator

   168         * @param aInterval The length of time after which the message

   169         *     is discarded by MMSC. Expressed in seconds.

   170         */

   171         IMPORT_C void SetExpiryInterval( TInt aInterval );

   172 

   173         /**

   174         * Expiration interval accessor.

   175         * @return Storage time of the message in MMSC (in seconds).

   176         */

   177         IMPORT_C TInt ExpiryInterval();

   178 

   179         /**

   180         * Expiration date mutator.

   181         * @param aDate The date and time the message will expire in seconds from 1970-01-01.

   182         *     Date must be in UTC time zone

   183         */

   184         IMPORT_C void SetExpiryDate( TInt64 aDate );

   185 

   186         /**

   187         * Expiration date accessor.

   188         * @return The date and time the message will expire in seconds from 1970-01-01.

   189         *     Date will be in UTC time zone

   190         */

   191         IMPORT_C TInt64 ExpiryDate();

   192 

   193         /**

   194         * Delivery time interval mutator.

   195         * @param aInterval The length of time after which the message will<br>

   196         *     be delivered to the recipient by the MMSC.<br>

   197         *     Expressed in seconds.

   198         */

   199         IMPORT_C void SetDeliveryTimeInterval( TInt aInterval );

   200 

   201         /**

   202         * Delivery time interval accessor.

   203         * @return delivery time interval of the message (in seconds).

   204         */

   205         IMPORT_C TInt DeliveryTimeInterval();

   206 

   207         /**

   208         * Delivery date mutator.

   209         * @param aDate The date and time the message will be delivered <br>

   210         *     to the recipient by the MMSC in seconds from 1970-01-01.

   211         *     Date must be in UTC time zone

   212         */

   213         IMPORT_C void SetDeliveryDate( TInt64 aDate );

   214 

   215         /**

   216         * Delivery date accessor.

   217         * @return The date and time the message will be delivered to the

   218         *     recipient by the MMSC in seconds from 1970-01-01.

   219         *     Date will be in UTC time zone

   220         */

   221         IMPORT_C TInt64 DeliveryDate();

   222 

   223         /**

   224         * Message priority mutator (Low/Normal/High). Default: Normal.

   225         * @param aPriority Message priority, values defined in MMSCONST.H

   226         */

   227         inline void SetMessagePriority( TInt aPriority );

   228 

   229         /**

   230         * Message priority accessor.

   231         * @return Message priority, values defined in MMSCONST.H

   232         */

   233         inline TInt MessagePriority() const;

   234 

   235         /**

   236         * Sender visibility mutator.

   237         * @param aVisibility Hide or Show (values defined in MMSCONST.H)

   238         */

   239         inline void SetSenderVisibility( TInt aVisibility );

   240 

   241         /**

   242         * Sender visibility accessor.

   243         * @return Hide or Show (values defined in MMSCONST.H)

   244         */

   245         inline TInt SenderVisibility();

   246 

   247         /**

   248         * Delivery Report Request mutator.

   249         * @param aRequest Yes or No (values defined in MMSCONST.H)

   250         */

   251         inline void SetDeliveryReport( TInt aRequest );

   252 

   253         /**

   254         * Delivery Report Request accessor.

   255         * @return Yes or No (values defined in MMSCONST.H)

   256         */

   257         inline TInt DeliveryReport();

   258 

   259         /**

   260         * Read Reply Request mutator.

   261         * @param aRequest Yes or No (values defined in MMSCONST.H)

   262         */

   263         inline void SetReadReply( TInt aRequest );

   264 

   265         /**

   266         * Read Reply Request accessor.

   267         * @return Yes or No (values defined in MMSCONST.H)

   268         */

   269         inline TInt ReadReply();

   270 

   271         /**

   272         * Message root part mutator.

   273         * @param aId Id of the message part that should be displayed

   274         *     first.<br>

   275         *     Should point to the SMIL part that starts the message display.

   276         */

   277         inline void SetMessageRoot( const TMsvAttachmentId aId );

   278 

   279         /**

   280         * Message root part accessor.

   281         * @return Id of the message part that should be displayed

   282         *     first.<br>

   283         *     Should point to the SMIL part that starts the message display.

   284         */

   285         inline TMsvAttachmentId MessageRoot( ) const;

   286                

   287         /** 

   288         * Give const access to the "To" recipient list

   289         * @return recipient list

   290         */

   291         inline const CDesCArray& ToRecipients() const;

   292 

   293         /** 

   294         * Give const access to the "Cc" recipient list

   295         * @return recipient list

   296         */

   297         inline const CDesCArray& CcRecipients() const;

   298 

   299         /** 

   300         * Give const access to the "Bcc" recipient list

   301         * @return recipient list

   302         */

   303         inline const CDesCArray& BccRecipients() const;

   304         

   305         /**

   306         * Content-Location mutator. Used in a Message Notification.

   307         * @param aURL URL of the message.

   308         */

   309         IMPORT_C void SetContentLocationL( const TDesC8& aURL );

   310 

   311         /**

   312         * Content-Location accessor. Used in a Message Notification.

   313         * @return URL of the message

   314         */

   315         IMPORT_C TPtrC8 ContentLocation() const;

   316 

   317         /**

   318         * Set Message-Size header.

   319         * @param aSize Message-Size in bytes. Used in a Message Notification.

   320         */

   321         inline void SetMessageSize( TInt aSize );

   322 

   323         /**

   324         * Get Message-Size. Used in a Message Notification.

   325         * @return Message-Size in bytes.

   326         */

   327         inline TInt MessageSize() const;

   328 

   329         /**

   330         * Size of the MMS headers object in memory. 

   331         * The multipart objet size is not included.

   332         * @return object size

   333         */

   334         IMPORT_C TInt Size() const;

   335 

   336         /**

   337         * Set Transaction-ID

   338         * @param aCid transaction ID

   339         */

   340         IMPORT_C void SetTidL( const TDesC8& aCid ); 

   341 

   342         /**

   343         * Get Transcation-ID

   344         * @return transaction id

   345         */

   346         IMPORT_C TPtrC8 Tid() const;

   347 

   348         /**

   349         * Set Message-Type

   350         * @param aType message type 

   351         */

   352         inline void SetMessageType( TInt aType ); 

   353 

   354         /**

   355         * Get Message-Type

   356         * @return message type.

   357         */

   358         inline TInt MessageType();

   359 

   360         /**

   361         * Set MMS-Version

   362         * @param aVersion MMS version

   363         */

   364         inline void SetMmsVersion( TInt16 aVersion );

   365 

   366         /**

   367         * Get MMS-Version

   368         * @return MMS-Version

   369         */

   370         inline TInt16 MmsVersion();

   371 

   372         /**

   373         * Set Date

   374         * @param aTime seconds from 1.1. 1970

   375         *     Date must be in UTC time zone

   376         */

   377         inline void SetDate( TInt64 aTime );

   378 

   379         /**

   380         * Get Date

   381         * @return seconds from 1.1. 1970

   382         *     Date will be in UTC time zone

   383         */

   384         inline TInt64 Date();

   385 

   386         /**

   387         * Report-Allowed accessor

   388         * @return Report-Allowed field value 

   389         */

   390         inline TInt32 ReportAllowed() const;

   391 

   392         /**

   393         * Report-Allowed mutator

   394         * @param aValue Report-Allowed value

   395         */

   396         inline void SetReportAllowed( TInt32 aValue );

   397 

   398         /**

   399         * Response-Status accessor

   400         * @return Response-Status field value 

   401         */

   402         inline TInt32 ResponseStatus() const;

   403 

   404         /**

   405         * Response-Status mutator

   406         * @param aValue Response-Status value

   407         */

   408         inline void SetResponseStatus( TInt32 aValue );

   409 

   410         /**

   411         * Message-ID mutator

   412         * @param aID Message-ID

   413         */

   414         IMPORT_C void SetMessageIdL( const TDesC8& aId ); 

   415 

   416         /**

   417         * Message-ID accessor

   418         * @return Message-ID

   419         */

   420         IMPORT_C TPtrC8 MessageId() const;

   421 

   422         /**

   423         * Status mutator

   424         * @param aStatus status value. See mmsconst.h.

   425         */

   426         inline void SetStatus( const TInt aStatus );

   427 

   428         /**

   429         * Status accessor

   430         * @return status value. See mmsconst.h.

   431         */

   432         inline TInt Status() const;

   433 

   434         // DEPRECATED

   435         // Legacy function, new version needs RFs (file system handle)

   436         /**

   437         * Make a copy of MmsHeaders

   438         * @param aParts message part list

   439         * @param aReply if the new message is a reply message. This has meaning

   440         *               for recipient handling.

   441         * @return MmsHeader object

   442         */

   443         IMPORT_C CMmsHeaders* CopyL( 

   444             TMsvPartList aParts,

   445             TBool aReply );

   446 

   447         /**

   448         * Set initial setting values from service settings

   449         * @param aSettings MMS service settings. Optional.

   450         */

   451         IMPORT_C void SetSettings(

   452             CMmsSettings* aSettings);

   453 

   454         /**

   455         * Maximum image size mutator.

   456         * @param aWidth image width

   457         * @param aHeight image height

   458         */

   459         IMPORT_C void SetMaximumImage( TInt aWidth, TInt aHeight );

   460 

   461         /**

   462         * Maximum image size accessor.

   463         * @param aWidth image width (OUT)

   464         * @param aHeight image height (OUT)

   465         */

   466         IMPORT_C void GetMaximumImage( TInt& aWidth, TInt& aHeight ) const;

   467 

   468         /**

   469         * Root Content-ID mutator.

   470         * @param aID Content-ID for message presentation part 

   471         */

   472         IMPORT_C void SetRootContentIdL( const TDesC8& aId ); 

   473 

   474         /**

   475         * Root Content-ID accessor.

   476         * @return Content-ID for message presentation part 

   477         */

   478         IMPORT_C TPtrC8 RootContentId() const;

   479 

   480         // new for MMS encapsulation version 1.1

   481         /**

   482         * Read status mutator.

   483         * @param aReadStatus status value. See mmsconst.h.

   484         */

   485         inline void SetReadStatus( const TInt aReadStatus );

   486 

   487         /**

   488         * Read status accessor.

   489         * @return Read status field value.

   490         */

   491         inline TInt ReadStatus() const;

   492 

   493         /**

   494         * ReplyCharging mutator.

   495         * @param aReplyCharging value. See mmsconst.h

   496         */

   497         inline void SetReplyCharging( const TInt aReplyCharging );

   498 

   499         /**

   500         * ReplyCharging accessor.

   501         * @return ReplyCharging status field

   502         */

   503         inline TInt ReplyCharging() const;

   504 

   505         /**

   506         * ReplyChargingSize mutator.

   507         * @param aReplyChargingSize maximum size of message for which

   508         *     reply charging applies.

   509         */

   510         inline void SetReplyChargingSize( const TInt aReplyChargingSize );

   511 

   512         /**

   513         * ReplyChargingSize accessor.

   514         * @return maximum size of message for which reply charging applies.

   515         */

   516         inline TInt ReplyChargingSize() const;

   517 

   518         /**

   519         * ReplyChargingID mutator.

   520         * @param aId original message ID to which this is a reply to

   521         */

   522         IMPORT_C void SetReplyChargingIdL( const TDesC8& aId ); 

   523          

   524         /**

   525         * ReplyChargingId accessor.

   526         * @return original message ID to which this is a reply to

   527         */

   528         IMPORT_C TPtrC8 ReplyChargingId() const;

   529 

   530         /**

   531         * ReplyCharging interval mutator.

   532         * @param aInterval The length of time during which the sender

   533         *     pays charges for reply. Expressed in seconds.

   534         */

   535         IMPORT_C void SetReplyChargingInterval( TInt aInterval );

   536 

   537         /**

   538         * ReplyCharging interval accessor.

   539         * @return The length of time during which the sender

   540         *     pays charges for reply. Expressed in seconds.

   541         */

   542         IMPORT_C TInt ReplyChargingInterval();

   543 

   544         /**

   545         * ReplyCharging date mutator.

   546         * @param aDate The date and time until which the sender pays charges

   547         * for reply in seconds from 1970-01-01.

   548         *     Date must be in UTC time zone

   549         */

   550         IMPORT_C void SetReplyChargingDate( TInt64 aDate );

   551 

   552         /**

   553         * ReplyCharging date accessor.

   554         * @return The date and time until which the sender pays charges for reply

   555         * in seconds from 1970-01-01.

   556         *     Date will be in UTC time zone

   557         */

   558         IMPORT_C TInt64 ReplyChargingDate();

   559 

   560         /*

   561         * Insert previous sender.

   562         * If corresponding entry is found, just insert sender to entry,

   563         * otherwise create new CMmsSendingChain item and insert it into array

   564         * @param aOrder the order number of the sending event

   565         * @param aSender the previous sender.

   566         */

   567         IMPORT_C void InsertPreviouslySentByL( TInt aOrder, const TDesC& aSender );

   568 

   569         /*

   570         * Insert previous sending date.

   571         * If corresponding entry is found, just inseret date to entry,

   572         * otherwise create new CMmsSendingChain item and insert it into array

   573         * @param aOrder the order number of the sending event

   574         * @param aDate the previous sending date, seconds from 1.1.1970 (UTC time).

   575         */

   576         IMPORT_C void InsertPreviouslySentDateL( TInt aOrder, TInt64 aDate );

   577 

   578         /*

   579         * Append new item to previously sent list

   580         * @param aDate the previous sending date, seconds from 1.1.1970 (UTC time).

   581         * @param aSender the previous sender.

   582         */

   583         IMPORT_C void AppendPreviouslySentItemL( TInt64 aDate, const TDesC& aSender );

   584 

   585         /*

   586         * Accessor to previously sent chain for looking at the content.

   587         * The items should normally be accessed in sequential order by outsiders.

   588         * @return reference to the sending chain array.

   589         */

   590         inline const RPointerArray<CMmsSendingChain>& PreviouslySentList();

   591 

   592         /**

   593         * Response text mutator.

   594         * Same string is used for Response text, Retrieve text and Status text

   595         * as all strings are information messages coming in from the MMSC and

   596         * only one of them can be present in any PDU

   597         * @param aText Response text string

   598         */

   599         IMPORT_C void SetResponseTextL( const TDesC& aText );

   600 

   601         /**

   602         * Response text accessor.

   603         * Same string is used for Response text, Retrieve text and Status text

   604         * as all strings are information messages coming in from the MMSC and

   605         * only one of them can be present in any PDU

   606         * @return Response text string.

   607         */

   608         IMPORT_C TPtrC ResponseText() const;

   609 

   610         /**

   611         * Creates a ContentId to be used in mime headers

   612         * @param aCid the created contentId (OUT)

   613         *     The caller must reserve a buffer that is at least 12 bytes long

   614         *     ( 10 bytes for a 32 bit integer converted to a string + angle brackets )

   615         */

   616         IMPORT_C static void CreateContentId( TDes8& aCid );

   617 

   618         /**

   619         * Distribution indicator accessor 

   620         * @since 2.6

   621         * @return X-Mms-DistributionIndicator value KMmsYes/KMmsNo

   622         */

   623         inline TInt DistributionIndicator() const;

   624 

   625         /**

   626         * Distribution indicator mutator

   627         * @since 2.6

   628         * @param aDistributionIndicator X-Mms-DistributionIndicator value KMmsYes/KMmsNo

   629         */

   630         inline void SetDistributionIndicator( const TInt aDistributionIndicator );

   631 

   632         /**

   633         * Related entry accessor

   634         * @since 2.6

   635         * @return Id of an entry that is connected to this one by some relationship

   636         * For example original notification entry in case of forward without retrieval

   637         */

   638         inline TMsvId RelatedEntry() const;

   639 

   640         /**

   641         * Related entry mutator

   642         * @since 2.6

   643         * @param aRelatedEntry Id of an entry that is connected to this one by some relationship

   644         */

   645         inline void SetRelatedEntry( const TMsvId aRelatedEntry );

   646 

   647         /**

   648         * Multipart type accessor

   649         * @since 2.6

   650         * @return type of multipart data saved to this entry (WSP assigned number)

   651         * 0 = unknown or not defined

   652         */

   653         inline TInt MultipartType() const;

   654 

   655         /**

   656         * Multipart type mutator

   657         * @since 2.6

   658         * @param aMultipartType type of multipart data saved to this entry (WSP assigned number)

   659         */

   660         inline void SetMultipartType( const TInt aMultipartType );

   661 

   662         // Read only accessors should be used when one must determine if data exists.

   663         // Editable accessors should be used when data will be stored to the members

   664         // No mutators are defined, these members are fully under control of CMmsHeaders

   665 

   666         /**

   667         * Element descriptor accessor for read only usage.

   668         * @since 2.6

   669         * @return pointer to element descriptor member for read only access.

   670         *     If no data has been defined for element descriptor, returns NULL.

   671         */

   672         inline const CMmsElementDescriptor* ReadOnlyElementDescriptor() const;

   673 

   674         /**

   675         * MMBox message headers accessor for read only usage

   676         * @since 2.6

   677         * @return pointer to MMBox message headers member for read only access.

   678         *     If no data has been defined for MMBox message headers, returns NULL.

   679         */

   680         inline const CMmsMMBoxMessageHeaders* ReadOnlyMMBoxMessageHeaders() const;

   681 

   682         /**

   683         * MMBox view headers accessor for read only usage

   684         * @since 2.6

   685         * @return pointer to MMBox view headers member for read only access.

   686         *     If no data has been defined for MMBox view headers, returns NULL.

   687         */

   688         inline const CMmsMMBoxViewHeaders* ReadOnlyMMBoxViewHeaders() const;

   689 

   690         /**

   691         * Element descriptor accessor for edit usage.

   692         * @since 2.6

   693         * @return reference to element descriptor member for edit access.

   694         *     If member pointer does not exist, it is created.

   695         *     This function must be used when data is to be added to CMmsElementDescriptor.

   696         */

   697         IMPORT_C CMmsElementDescriptor& ElementDescriptorL();

   698 

   699         /**

   700         * MMBox message headers accessor for edit usage

   701         * @since 2.6

   702         * @return reference to MMBox message headers member for edit access.

   703         *     If member pointer does not exist, it is created.

   704         *     This function must be used when data is to be added to CMmsMMBoxMessageHeaders.

   705         */

   706         IMPORT_C CMmsMMBoxMessageHeaders& MMBoxMessageHeadersL();

   707 

   708         /**

   709         * MMBox view headers accessor for edit usage

   710         * @since 2.6

   711         * @return reference to MMBox view headers member for edit access.

   712         *     If member pointer does not exist, it is created.

   713         *     This function must be used when data is to be added to CMmsMMBoxViewHeaders.

   714         */

   715         IMPORT_C CMmsMMBoxViewHeaders& MMBoxViewHeadersL();

   716 

   717         /**

   718         * Extended Notification mutator.

   719         * @since 2.6

   720         * @param aText Extended notification text.

   721         */

   722         IMPORT_C void SetExtendedNotificationL( const TDesC& aText );

   723 

   724         /**

   725         * Extended Notification accessor.

   726         * @since 2.6

   727         * @return Extended notification text.

   728         */

   729         IMPORT_C TPtrC ExtendedNotification() const; 

   730 

   731         /**

   732         * Message complete indicator mutator

   733         * @since 2.6

   734         * @param aExtensionStatus indicator that tells if the  whole message fits into

   735         *     extension text string.

   736         *     0x20 = Message body size > text, message retrieval uncomplete

   737         *     0x30 = Message retrieval complete (whole message body in IExtendedNotificationText)

   738         *     other values reserved.

   739         */

   740         inline void SetMessageComplete( TInt aExtensionStatus );

   741 

   742         /**

   743         * Message complete indicator accessor.

   744         * @since 2.6

   745         * @return status that tells if the  whole message fits into extension text string.

   746         *     0x20 = Message body size > text, message retrieval uncomplete

   747         *     0x30 = Message retrieval complete (whole message body in IExtendedNotificationText)

   748         *     other values reserved.

   749         */

   750         inline TInt MessageComplete();

   751 

   752         /**

   753         * Accessor to delete result array for looking at the content.

   754         * The items should normally be accessed in sequential order by outsiders.

   755         * @return reference to the delete result array.

   756         */

   757         inline const RPointerArray<CMmsDeleteResultArray>& DeleteResultArray();

   758 

   759         /**

   760         * Insert delete status.

   761         * If corresponding entry is found, just insert delete status to entry,

   762         * otherwise create new CMmsDeleteResultArray item and insert it into array

   763         * @param aOrder the order number of the not deleted entry

   764         * @param aStatus the previous sender.

   765         */

   766         IMPORT_C void InsertDeleteStatusL( TUint aOrder, const TInt32 aStatus );

   767 

   768         /**

   769         * Insert delete result content location.

   770         * If corresponding entry is found, just insert content location to entry,

   771         * otherwise create new CMmsDeleteResultArray item and insert it into array

   772         * @param aOrder the order number of the not deleted entry

   773         * @param aContentlocation content location.

   774         */

   775         IMPORT_C void InsertDeleteContentLocationL( TUint aOrder, const TDesC8& aContentLocation );

   776 

   777         /**

   778         * Insert delete result response text.

   779         * If corresponding entry is found, just insert response text to entry,

   780         * otherwise create new CMmsDeleteResultArray item and insert it into array

   781         * @param aOrder the order number of the not deleted entry

   782         * @param aResponseText content location.

   783         */

   784         IMPORT_C void InsertDeleteResponseTextL( TUint aOrder, const TDesC& aResposeText );

   785         

   786         /**

   787         * Save the time when the message was received.

   788         *     This header allows the iDate field in TMsvEntry to contain

   789         *     either the receiving time or the sending time. If the TMsvEntry

   790         *     shows the sending time, the receiving time can be accessed through

   791         *     this field.

   792         * @param aTime time in UTC time zone when the message has been received.

   793         */

   794         inline void SetReceivingTime( TTime aTime );

   795         

   796         /**

   797         * The time the message was received in the terminal.

   798         * @return Message receiving time

   799         */

   800         inline TTime ReceivingTime() const; 

   801         

   802         /**

   803         * Identification of the destination application mutator.

   804         * @param aApplicId application ID

   805         */

   806         IMPORT_C void SetApplicIdL( const TDesC16& aApplicId );

   807 

   808         /**

   809         * Identification of the destination application accessor.

   810         * @return Application ID.

   811         */

   812         IMPORT_C TPtrC16 ApplicId() const;

   813         

   814         /**

   815         * Identification of an application to which replies are addressed mutator.

   816         * @param aApplicId reply to application ID

   817         */

   818         IMPORT_C void SetReplyApplicIdL( const TDesC16& aApplicId );

   819 

   820         /**

   821         * Identification of an application to which replies are addressed accessor.

   822         * @return Reply to Application ID.

   823         */

   824         IMPORT_C TPtrC16 ReplyApplicId() const;

   825         

   826         /**

   827         * Auxiliary application information for internal use of the destination

   828         * application mutator.

   829         * @param aAuxApplicInfo auxiliary application info

   830         */

   831         IMPORT_C void SetAuxApplicInfoL( const TDesC8& aAuxApplicInfo );

   832 

   833         /**

   834         * Auxiliary application information for internal use of the destination

   835         * application accessor.

   836         * @return auxiliary application info.

   837         */

   838         IMPORT_C TPtrC8 AuxApplicInfo() const;

   839 

   840         /**

   841         * Make a copy of MmsHeaders

   842         *

   843         * @since 3.1

   844         * @param aParts message part list

   845         * @param aReply if the new message is a reply message. This has meaning

   846         *               for recipient handling.

   847         * @param aFs file system handle. Needed for alias handling

   848         * @return MmsHeader object

   849         */

   850         IMPORT_C CMmsHeaders* CopyL( 

   851             TMsvPartList aParts,

   852             TBool aReply,

   853             RFs& aFs );

   854             

   855         /**

   856         * Set the content class of the message  as specified in MMS encapsulation 1.3-

   857         * @param aContentClass content class value from mmsconst.h

   858         * - KMmsContentClassText

   859         * - KMmsContentClassImageBasic

   860         * - KMmsContentClassImageRich

   861         * - KMmsContentClassVideoBasic

   862         * - KMmsContentClassVideoRich

   863         * - KMmsContentClassMegaPixel

   864         * - KMmsContentClassContentBasic

   865         * - KMmsContentClassContentRich

   866         */

   867         inline void SetContentClass( TInt aContentClass );

   868         

   869         /**

   870         * Return the content class value as specified in MMS encapsulation 1.3.

   871         * @return Content class value

   872         * - 0 content class not defined

   873         * - KMmsContentClassText ... KMmsContentClassContentRich defined content class.

   874         */

   875         inline TInt ContentClass() const;

   876         

   877         /**

   878         * Set DRM Content indicator header.

   879         * @param aDrmContent Messag has DRM content. Possible values:

   880         * - KMmsYes

   881         * - KMmsNo

   882         */

   883         inline void SetDrmContent( TInt aDrmContent );

   884         

   885         /**

   886         * Get DRM content indicator (encapsulation 1.3)

   887         * @return DRM indicator header. Possible values:

   888         * - KMmsYes

   889         * - KMmsNo

   890         */

   891         inline TInt DrmContent() const;

   892         

   893         /**

   894         * Set the header that tells if MMSC is allowed to alter the message (make it smaller).

   895         * @param aAdaptationAllowed Adaptation allowed header. Possible values:

   896         * - KMmsYes

   897         * - KMmsNo

   898         */

   899         inline void SetAdaptationAllowed( TInt aAdaptationAllowed );

   900         

   901         /**

   902         * Get header that tells if MMSC is allowed to alter the message (make it smaller).

   903         * @return Adaptation allowed header. Possible values:

   904         * - KMmsYes

   905         * - KMmsNo

   906         */

   907         inline TInt AdaptationAllowed() const;

   908         

   909         /**

   910         * Set recommended retrieval mode.

   911         * This header appears in a notification and may recommend manual retrieval.

   912         * @param aRetrievalMode Suggested retrieval mode. Possible values

   913         * - KMmsRecommendedRetrievalModeManual

   914         */

   915         inline void SetRecommendedRetrievalMode( TInt aRetrievalMode );

   916         

   917         /**

   918         * Get recommended retrieval mode

   919         * This header appears in a notification and may recommend manual retrieval.

   920         * @return Suggested retrieval mode. Possible values

   921         * - KMmsRecommendedRetrievalModeManual

   922         * 0 not defined

   923         */

   924         inline TInt RecommendedRetrievalMode() const;

   925         

   926         /**

   927         * Set explanation why retrival mode is recommended

   928         * @param explanantion for recommended retrieval mode

   929         */

   930         IMPORT_C void SetRecommendedRetrievalModeTextL(

   931             const TDesC16& aRecommendedRetrievalModeText );

   932 

   933         /**

   934         * Get explanation why retrival mode is recommended

   935         * @return explanantion for recommended retrieval mode

   936         */

   937         IMPORT_C TPtrC16 RecommendedRetrievalModeText() const;

   938 

   939         /**

   940         * Set id of message to be replaced or cancelled

   941         * @param id of message to be replaced or cancelled

   942         */

   943         IMPORT_C void SetReplaceCancelIdL( const TDesC8& aReplaceCancelId );

   944 

   945         /**

   946         * Get id of message to be replaced or cancelled

   947         * @return id of message to be replaced or cancelled

   948         */

   949         IMPORT_C TPtrC8 ReplaceCancelId() const;

   950         

   951         /**

   952         * Set status of cancel operation

   953         * @param aCancelStatus Status of cancel operation. Possible values:

   954         * - KMmsCancelRequestSuccessfullyReceived

   955         * - KMmsCancelRequestCorrupted

   956         */

   957         inline void SetCancelStatus( TInt aCancelStatus );

   958         

   959         /**

   960         * Get status of cancel operation

   961         * @return aCancelStatus Status of cancel operation. Possible values:

   962         * - KMmsCancelRequestSuccessfullyReceived

   963         * - KMmsCancelRequestCorrupted

   964         * 0 not defined

   965         */

   966         inline TInt CancelStatus() const;

   967         

   968 

   969     public: // Functions from base classes

   970 

   971         

   972     protected:  // New functions

   973         

   974 

   975     protected:  // Functions from base classes

   976         

   977 

   978     private:

   979 

   980         /**

   981         * C++ default constructor.

   982         */

   983         CMmsHeaders();

   984 

   985         /**

   986         * By default Symbian OS constructor is private.

   987         */

   988         void ConstructL( TInt16 aMmsDefaultVersion );

   989 

   990         /**

   991         * Internalize.

   992         * @param aStream read stream

   993         */

   994         IMPORT_C void InternalizeL( RMsvReadStream& aStream );

   995 

   996         /**

   997         * Externalize.

   998         * @param aStream write stream

   999         */

  1000         IMPORT_C void ExternalizeL( RMsvWriteStream& aStream ) const;

  1001 

  1002         /**

  1003         * Remove a addressee from a given addressee list.

  1004         * @param aList addressee list

  1005         * @param aAddress addressee to match

  1006         * @return ETrue if matched and deleted.

  1007         */

  1008         TBool RemoveAddressee(

  1009             CDesCArray& aList,

  1010             const TDesC& aAddress );

  1011 

  1012         /**

  1013         * Externalize Array. 

  1014         * @param anArray the array to be externalized

  1015         * @param aStream stream where to write.

  1016         */

  1017         void ExternalizeArrayL(

  1018             CDesC16Array& anArray,

  1019             RWriteStream& aStream ) const;

  1020 

  1021         /**

  1022         * Internalize Array.

  1023         * @param anArray the array where to write data

  1024         * @param aStream a stream where to read data from

  1025         */

  1026         void InternalizeArrayL(

  1027             CDesC16Array& anArray,

  1028             RReadStream& aStream );

  1029  

  1030         /**

  1031         * Copy addressee list from source headers

  1032         * @param aArray addressee list

  1033         * @param aType recipient lins type

  1034         * @param aExclude Address to be excluded from the list (sender)

  1035         * @param aFs file system handle

  1036         */

  1037         void CopyAddresseeListL(

  1038             const CDesCArray& aArray,

  1039             TMmsRecipients aType,

  1040             const TPtrC& aExclude,

  1041             RFs& aFs );

  1042 

  1043         /**

  1044         * Generate aliased address from an address that may be pure or not <br>

  1045         * Caller must free buffer when no lenger needed

  1046         * @param aOriginalAddress original address may be pure or not

  1047         * @param aFs file system handle

  1048         * @return combined address in format: <br>

  1049         *    alias<real_address>

  1050         */

  1051         HBufC* AliasedAddressL(

  1052             const TDesC& aOriginalAddress,

  1053             RFs& aFs ); 

  1054             

  1055             

  1056         /**

  1057         * Generate array of aliased addresses from an arrays of addresses

  1058         * that may be pure or not <br>

  1059         * Caller must free the array when no lenger needed

  1060         * @param aOriginalAddress array of original addresses, may be pure or not

  1061         * @return array of addresses in format: <br>

  1062         *    alias<real_address>

  1063         */

  1064         CDesCArray* AliasedAddressL(

  1065             const CDesCArray& aOriginalAddress, 

  1066             RFs& aFs );

  1067             

  1068         /**

  1069         * Limit string size to maximum length

  1070         * @param aString input string

  1071         * @param aMaxSize maximum length of the string

  1072         */

  1073         static TPtrC8 LimitStringSize(const TPtrC8& aString, TInt aMaxSize);

  1074         

  1075         /**

  1076         * Limit string size to maximum length

  1077         * @param aString input string

  1078         * @param aMaxSize maximum length of the string

  1079         */

  1080         static TPtrC16 LimitStringSize(const TPtrC16& aString, TInt aMaxSize);

  1081     

  1082 

  1083 

  1084     public:     // Data

  1085     

  1086     protected:  // Data

  1087 

  1088     private:    // Data

  1089         TInt32          iMsgType;       // Message-Type;

  1090         HBufC8*         iTID;           // Transaction ID

  1091         TInt16          iVersion;       // MMS-version

  1092         TInt64          iDate;          // Date

  1093 

  1094         CDesCArray*     iToArray;       // TO headers

  1095         CDesCArray*     iCcArray;       // Cc headers

  1096         CDesCArray*     iBccArray;      // Bcc headers

  1097         HBufC*          iSender;        // From header

  1098 

  1099         HBufC*          iSubject;       // Subject

  1100 

  1101         TInt32          iMsgClass;      // Message-Class

  1102 

  1103         TInt64          iExpiry;        // Expiry

  1104         TBool           iExpiryAbs;     // Is the iExpiry time absolute time

  1105         TInt64          iDelivery;      // Delivery

  1106         TBool           iDeliveryAbs;   // Is iDelivery absolute time

  1107         TInt32          iPriority;      // Priority

  1108         TInt32          iSenderVisi;    // Sender-Visibility

  1109         TInt32          iDelivReport;   // Delivery-Report

  1110         TInt32          iReadReply;     // Read-Reply

  1111 

  1112         TMsvAttachmentId iStart;         // root part of the message

  1113 

  1114         HBufC8*         iContentLocation;   // Content-Location

  1115         TUint32         iMessageSize;       // Message-Size 

  1116 

  1117         TInt32          iReportAllowed;     // Report-Allowed

  1118         TInt32          iResponseStatus;    // Response-Status

  1119         HBufC8*         iMessageId;         // Message-ID

  1120 

  1121         TInt32          iStatus;            // Status

  1122 

  1123         TInt32          iMaxImageHeight;    // maximum image height

  1124         TInt32          iMaxImageWidth;     // maximum image width

  1125 

  1126         HBufC*          iOperatorResponseText; // Operator response in send-conf or retrieve-conf

  1127         HBufC8*         iRootContentID;  // content-id of the root message part.

  1128 

  1129         // new fields for MMS encapsulation version 1.1

  1130         // Retrieve status is stored into same variable as response status

  1131         // response status comes in send confirmation,

  1132         // retrieve status comes in retrieve confirmation.

  1133         // Both have the same meaning indicating success or failure of the operation

  1134 

  1135         TInt32          iReadStatus;        // status from a read report