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 implementation

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include    <msvstore.h>

    22 #include    <badesca.h>

    23 #include    <msvids.h>

    24 #include    <mtmdef.h>

    25 #include    <e32def.h>

    26 #include    <e32math.h>

    27 #include    <mmsvattachmentmanager.h>

    28 #include    <cmsvmimeheaders.h>

    29 #include    "mmsconst.h"

    30 #include    "mmsheaders.h"

    31 #include    "mmssettings.h"

    32 #include    "mmsversion.h"

    33 #include    "mmselementdescriptor.h"

    34 #include    "mmsmmboxmessageheaders.h"

    35 #include    "mmsmmboxviewheaders.h"

    36 

    37 // EXTERNAL DATA STRUCTURES

    38 

    39 // EXTERNAL FUNCTION PROTOTYPES  

    40 

    41 // CONSTANTS

    42 const TInt KMmsArrayAllocationNumber = 6;

    43 

    44 // MACROS

    45 

    46 // LOCAL CONSTANTS AND MACROS

    47 

    48 // MODULE DATA STRUCTURES

    49 

    50 // LOCAL FUNCTION PROTOTYPES

    51 

    52 // ==================== LOCAL FUNCTIONS ====================

    53 

    54 

    55 // ================= MEMBER FUNCTIONS =======================

    56 

    57 // C++ default constructor can NOT contain any code that

    58 // might leave.

    59 //

    60 CMmsHeaders::CMmsHeaders():

    61     iLinearOrder( CMmsSendingChain::Compare ),

    62     iDeleteResultOrder( CMmsDeleteResultArray::Compare )

    63 // in a class derived from CBase all member variables are set initially to 0

    64     {

    65     }

    66 

    67 // Symbian OS default constructor can leave.

    68 void CMmsHeaders::ConstructL( TInt16 aMmsDefaultVersion )

    69     {

    70     iToArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    71     iCcArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    72     iBccArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    73     iMmsDefaultVersion = aMmsDefaultVersion;

    74     if ( iMmsDefaultVersion < KMmsMinimumSupportedVersion ||

    75         iMmsDefaultVersion > KMmsMaximumSupportedVersion )

    76         {

    77         // The supported default version must be within limits.

    78         // The actual messages can carry any version

    79         iMmsDefaultVersion = KMmsDefaultVersion;

    80         }

    81     Reset( NULL );

    82     }

    83 

    84 // Two-phased constructor.

    85 EXPORT_C CMmsHeaders* CMmsHeaders::NewL( TInt16 aMmsVersion )

    86     {

    87     CMmsHeaders* self = new ( ELeave ) CMmsHeaders;

    88     

    89     CleanupStack::PushL( self );

    90     // default value for legacy applications that are not aware of mms version

    91     self->ConstructL( aMmsVersion );

    92     CleanupStack::Pop( self );

    93 

    94     return self;

    95     }

    96 

    97 // Two-phased constructor.

    98 EXPORT_C CMmsHeaders* CMmsHeaders::NewL()

    99     {

   100     CMmsHeaders* self = new ( ELeave ) CMmsHeaders;

   101     

   102     CleanupStack::PushL( self );

   103     // default value for legacy applications that are not aware of mms version

   104     self->ConstructL( KMmsDefaultVersion );

   105     CleanupStack::Pop( self );

   106 

   107     return self;

   108     }

   109     

   110 // Destructor

   111 CMmsHeaders::~CMmsHeaders()

   112     {

   113     iPreviouslySentArray.ResetAndDestroy();

   114     iDeleteResultArray.ResetAndDestroy();

   115     delete iOperatorResponseText;

   116     delete iReplyChargingId;

   117     delete iToArray;

   118     delete iCcArray;

   119     delete iBccArray;

   120     delete iSender;

   121     delete iContentLocation;

   122     delete iSubject;

   123     delete iTID;

   124     delete iMessageId;

   125     delete iRootContentID;

   126     delete iElementDescriptor;

   127     delete iMmBoxMessageHeaders;

   128     delete iMmBoxViewHeaders;

   129     delete iExtendedNotificationText;

   130     delete iApplicationId;

   131     delete iReplyToApplicationId;

   132     delete iApplicationInfo;

   133     delete iRecommendedRetrievalModeText;

   134     delete iReplaceCancelId;

   135     }

   136 

   137 // ---------------------------------------------------------

   138 // CMmsHeaders::RestoreL

   139 //

   140 // ---------------------------------------------------------

   141 //

   142 

   143 EXPORT_C void CMmsHeaders::RestoreL(

   144     CMsvStore& aStore )

   145     {

   146 

   147     RMsvReadStream stream;

   148     Reset( NULL ); // all old pointers are deleted here

   149     if ( aStore.IsPresentL( KUidMmsHeaderStream ) )

   150         {

   151         stream.OpenLC( aStore, KUidMmsHeaderStream ); // pushes 'stream' to the stack

   152         InternalizeL( stream );

   153         CleanupStack::PopAndDestroy( &stream ); // close stream

   154         }

   155     // restore MMBox header streams if present

   156     if ( aStore.IsPresentL( KUidMMsElementDescriptorStream ) )

   157         {

   158         stream.OpenLC( aStore, KUidMMsElementDescriptorStream ); // pushes 'stream' to the stack

   159         iElementDescriptor = new( ELeave )CMmsElementDescriptor;

   160         iElementDescriptor->InternalizeL( stream );

   161         CleanupStack::PopAndDestroy( &stream ); // close stream

   162         }

   163     if ( aStore.IsPresentL( KUidMMsMMBoxMessageHeaderStream ) )

   164         {

   165         stream.OpenLC( aStore, KUidMMsMMBoxMessageHeaderStream ); // pushes 'stream' to the stack

   166         iMmBoxMessageHeaders = CMmsMMBoxMessageHeaders::NewL();

   167         iMmBoxMessageHeaders->InternalizeL( stream );

   168         CleanupStack::PopAndDestroy( &stream ); // close stream

   169         }

   170     if ( aStore.IsPresentL( KUidMMsMMBoxViewHeadersStream ) )

   171         {

   172         stream.OpenLC( aStore, KUidMMsMMBoxViewHeadersStream ); // pushes 'stream' to the stack

   173         iMmBoxViewHeaders = new( ELeave )CMmsMMBoxViewHeaders;

   174         iMmBoxViewHeaders->InternalizeL( stream );

   175         CleanupStack::PopAndDestroy( &stream ); // close stream

   176         }

   177 

   178     // Extended notification also restored here

   179     TInt length = 0; // string length

   180 

   181     // Completeness indicator is not saved or restored.

   182     // If we have stored the text, it normally indicates that the message is not complete

   183     if ( aStore.IsPresentL( KUidMMsExtendedNotificationStream ) )

   184         {

   185         stream.OpenLC( aStore, KUidMMsExtendedNotificationStream ); // pushes 'stream' to the stack

   186         length = stream.ReadInt32L();

   187         if ( length > 0 )

   188             {

   189             iExtendedNotificationText = HBufC::NewL( stream, length );

   190             }

   191         CleanupStack::PopAndDestroy( &stream ); // close stream

   192         }

   193     

   194     if ( aStore.IsPresentL( KUidMmsApplicationInfoStream ) )

   195         {

   196         stream.OpenLC( aStore, KUidMmsApplicationInfoStream ); // pushes 'stream' to the stack

   197         length = stream.ReadInt32L();

   198         if ( length > 0 )

   199             {

   200             iApplicationId = HBufC::NewL( stream, length );

   201             }

   202         length = stream.ReadInt32L();

   203         if ( length > 0 )

   204             {

   205             iReplyToApplicationId = HBufC::NewL( stream, length );

   206             }

   207         length = stream.ReadInt32L();

   208         if ( length > 0 )

   209             {

   210             iApplicationInfo = HBufC8::NewL( stream, length );

   211             }

   212         

   213         CleanupStack::PopAndDestroy( &stream ); // close stream

   214         }

   215         

   216     if ( aStore.IsPresentL( KUidMmsReserved ) )

   217         {

   218         stream.OpenLC( aStore, KUidMmsReserved ); // pushes 'stream' to the stack

   219         iRecommendedRetrievalMode = stream.ReadInt32L();

   220         length = stream.ReadInt32L();

   221         if ( length > 0 )

   222             {

   223             iRecommendedRetrievalModeText = HBufC16::NewL( stream, length );

   224             }

   225         length = stream.ReadInt32L();

   226         if ( length > 0 )

   227             {

   228             iReplaceCancelId = HBufC8::NewL( stream, length );

   229             }

   230         iCancelStatus = stream.ReadInt32L();

   231         CleanupStack::PopAndDestroy( &stream ); // close stream

   232         }

   233         

   234     } 

   235 

   236 // ---------------------------------------------------------

   237 // CMmsEntry::StoreL

   238 //

   239 // ---------------------------------------------------------

   240 //

   241 

   242 EXPORT_C void CMmsHeaders::StoreL(

   243     CMsvStore& aStore )

   244     {

   245 

   246     // Check if message root is correctly set

   247     // We have an edit store in our hands, so we can access the attachment manager

   248     

   249     if ( iStart != 0 )

   250         {

   251         MMsvAttachmentManager& attaMan = aStore.AttachmentManagerL();

   252         CMsvAttachment* attaInfo = NULL;

   253         TRAPD( error, attaInfo = attaMan.GetAttachmentInfoL( iStart ) );

   254         if ( error == KErrNotFound )

   255             {

   256             // The attachment is not present, clear the root indicator

   257             iStart = 0;

   258             delete iRootContentID;

   259             iRootContentID = 0;

   260             }

   261         else if ( error == KErrNone )

   262             {

   263             // got the attachment, check content id

   264             CleanupStack::PushL( attaInfo );

   265             CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

   266             CleanupStack::PushL( mimeHeaders );

   267             mimeHeaders->RestoreL( *attaInfo );

   268             if ( RootContentId().Compare( mimeHeaders->ContentId() ) != 0 )

   269                 {

   270                 if ( mimeHeaders->ContentId().Length() > 0 )

   271                     {

   272                     // mime headers win

   273                     SetRootContentIdL( mimeHeaders->ContentId() );

   274                     }

   275                 else if ( RootContentId().Length() > 0 )

   276                     {

   277                     // if mime headers not set, but root set, root wins

   278                     mimeHeaders->SetContentIdL( RootContentId() );

   279                     mimeHeaders->StoreL( *attaInfo );

   280                     }

   281                 else

   282                     {

   283                     // keep LINT happy

   284                     }

   285                 }

   286             CleanupStack::PopAndDestroy( mimeHeaders );

   287             CleanupStack::PopAndDestroy( attaInfo );

   288             }

   289         // If error == KErrNoMemory there is nothing we can do

   290         // We try to continue anyway, maybe we still can save our message

   291         else

   292             {

   293             // Keep LINT happy.

   294             }

   295         }

   296     

   297     // caller must commit the store

   298     RMsvWriteStream stream;

   299     stream.AssignLC( aStore, KUidMmsHeaderStream ); // pushes 'stream' to the stack

   300     ExternalizeL( stream );

   301     stream.CommitL();

   302     stream.Close();

   303     CleanupStack::PopAndDestroy( &stream ); // close stream

   304 

   305     // store element descriptor and  mmbox headers, if they are present

   306     if ( iElementDescriptor )

   307         {

   308         stream.AssignLC( aStore, KUidMMsElementDescriptorStream ); // pushes 'stream' to the stack

   309         iElementDescriptor->ExternalizeL( stream );

   310         stream.CommitL();

   311         stream.Close();

   312         CleanupStack::PopAndDestroy( &stream ); // close stream

   313         }

   314     if ( iMmBoxMessageHeaders )

   315         {

   316         stream.AssignLC( aStore, KUidMMsMMBoxMessageHeaderStream ); // pushes 'stream' to the stack

   317         iMmBoxMessageHeaders->ExternalizeL( stream );

   318         stream.CommitL();

   319         stream.Close();

   320         CleanupStack::PopAndDestroy( &stream ); // close stream

   321         }

   322     if ( iMmBoxViewHeaders )

   323         {

   324         stream.AssignLC( aStore, KUidMMsMMBoxViewHeadersStream ); // pushes 'stream' to the stack

   325         iMmBoxViewHeaders->ExternalizeL( stream );

   326         stream.CommitL();

   327         stream.Close();

   328         CleanupStack::PopAndDestroy( &stream ); // close stream

   329         }

   330 

   331     TInt length = 0; // 

   332     // store extended notification if present

   333     if ( iExtendedNotificationText )

   334         {

   335         stream.AssignLC( aStore, KUidMMsExtendedNotificationStream ); // pushes 'stream' to the stack

   336         length = ExtendedNotification().Length();

   337         stream.WriteInt32L( length );

   338         if ( length > 0 )

   339             {

   340             stream << ExtendedNotification();

   341             }

   342         stream.CommitL();

   343         stream.Close();

   344         CleanupStack::PopAndDestroy( &stream ); // close stream

   345         }

   346         

   347     if ( iApplicationId ||

   348         iReplyToApplicationId ||

   349         iApplicationInfo )

   350         {

   351         stream.AssignLC( aStore, KUidMmsApplicationInfoStream ); // pushes 'stream' to the stack

   352         length = ApplicId().Length();

   353         stream.WriteInt32L( length );

   354         if ( length > 0 )

   355             {

   356             stream << iApplicationId->Des();

   357             }

   358         

   359         length = ReplyApplicId().Length();

   360         stream.WriteInt32L( length );

   361         if ( length > 0 )

   362             {

   363             stream << iReplyToApplicationId->Des();

   364             }

   365         

   366         length = AuxApplicInfo().Length();

   367         stream.WriteInt32L( length );

   368         if ( length > 0 )

   369             {

   370             stream << iApplicationInfo->Des();

   371             }

   372         

   373         stream.CommitL();

   374         stream.Close();

   375         CleanupStack::PopAndDestroy( &stream ); // close stream

   376         }

   377 

   378     // reserved transaction info stream

   379     if ( iRecommendedRetrievalMode != 0 ||

   380         iRecommendedRetrievalModeText ||

   381         iReplaceCancelId ||

   382         iCancelStatus != 0 )

   383         {

   384         stream.AssignLC( aStore, KUidMmsReserved ); // pushes 'stream' to the stack

   385         

   386         stream.WriteInt32L( iRecommendedRetrievalMode );

   387 

   388         length = RecommendedRetrievalModeText().Length();

   389         stream.WriteInt32L( length );

   390         if ( length > 0 )

   391             {

   392             stream << iRecommendedRetrievalModeText->Des();

   393             }

   394             

   395         length = ReplaceCancelId().Length();

   396         stream.WriteInt32L( length );

   397         if ( length > 0 )

   398             {

   399             stream << iReplaceCancelId->Des();

   400             }

   401         

   402         stream.WriteInt32L( iCancelStatus );

   403         

   404         stream.CommitL();

   405         stream.Close();

   406         CleanupStack::PopAndDestroy( &stream ); // close stream

   407         }

   408 

   409     }

   410 

   411 // ---------------------------------------------------------

   412 // CMmsHeaders::TypedAddresseeList

   413 //

   414 // ---------------------------------------------------------

   415 //

   416 EXPORT_C const CDesCArray& CMmsHeaders::TypedAddresseeList( 

   417     TMmsRecipients aType ) 

   418     {

   419 

   420     TInt type = aType;

   421 

   422     if (type == EMmsTo)

   423         {

   424         return *iToArray;

   425         }

   426     else if ( type == EMmsCc )

   427         {

   428         return *iCcArray;

   429         }

   430     else 

   431         {

   432         return *iBccArray;

   433         }

   434     }

   435    

   436 // ---------------------------------------------------------

   437 // CMmsHeaders::AddTypedAddresseeL

   438 //

   439 // ---------------------------------------------------------

   440 //

   441 EXPORT_C void CMmsHeaders::AddTypedAddresseeL( 

   442     const TDesC&  aRealAddress, 

   443     TMmsRecipients aType  )

   444     {

   445     

   446     TInt type = aType;

   447 

   448     if ( type == EMmsTo )

   449         {

   450         iToArray->AppendL( aRealAddress );

   451         }

   452     if ( type == EMmsCc )

   453         {

   454         iCcArray->AppendL( aRealAddress );

   455         }

   456     if ( type == EMmsBcc ) 

   457         {

   458         iBccArray->AppendL( aRealAddress );

   459         }

   460     }

   461 

   462 // ---------------------------------------------------------

   463 // CMmsHeaders::RemoveAddresseeL

   464 //

   465 // ---------------------------------------------------------

   466 //

   467 EXPORT_C TBool CMmsHeaders::RemoveAddressee( const TDesC& aRealAddress )

   468     {

   469 

   470     if ( RemoveAddressee( *iToArray, aRealAddress) )

   471         {

   472         return ETrue;

   473         }

   474     if ( RemoveAddressee( *iCcArray, aRealAddress) )

   475         {

   476         return ETrue;

   477         }

   478     if ( RemoveAddressee( *iBccArray, aRealAddress) )

   479         {

   480         return ETrue;

   481         }

   482       

   483     return EFalse;

   484 

   485     }

   486 

   487 // ---------------------------------------------------------

   488 // CMmsHeaders::SetSubjectL

   489 //

   490 // ---------------------------------------------------------

   491 //

   492 EXPORT_C void CMmsHeaders::SetSubjectL( const TDesC& aSubject )

   493     {

   494     HBufC* newAttrib = aSubject.AllocL();

   495     delete iSubject;

   496     iSubject = newAttrib;

   497     }

   498 

   499 // ---------------------------------------------------------

   500 // CMmsHeaders::Subject

   501 //

   502 // ---------------------------------------------------------

   503 //

   504 EXPORT_C TPtrC CMmsHeaders::Subject() const

   505     {

   506     return iSubject ? TPtrC( *iSubject ) : TPtrC(); 

   507     }

   508 

   509 // ---------------------------------------------------------

   510 // CMmsHeaders::SetSenderL

   511 //

   512 // ---------------------------------------------------------

   513 //

   514 EXPORT_C void CMmsHeaders::SetSenderL( const TDesC& aAlias )

   515     {

   516     HBufC* newAttrib = aAlias.AllocL();

   517     delete iSender;

   518     iSender = newAttrib;

   519     }

   520 

   521 // ---------------------------------------------------------

   522 // CMmsHeaders::Sender

   523 //

   524 // ---------------------------------------------------------

   525 //

   526 EXPORT_C TPtrC CMmsHeaders::Sender() const

   527     {

   528     return iSender ? TPtrC( *iSender ) : TPtrC(); 

   529     }

   530 

   531 // ---------------------------------------------------------

   532 // CMmsHeaders::SetExpiryInterval

   533 //

   534 // ---------------------------------------------------------

   535 //

   536 EXPORT_C void CMmsHeaders::SetExpiryInterval( 

   537     TInt aInterval )

   538     {

   539     iExpiry = aInterval;

   540     iExpiryAbs = EFalse;

   541     }

   542 

   543 // ---------------------------------------------------------

   544 // CMmsHeaders::ExpiryInterval

   545 //

   546 // ---------------------------------------------------------

   547 //

   548 EXPORT_C TInt CMmsHeaders::ExpiryInterval()

   549     {

   550     return iExpiryAbs ? 0 : I64LOW( iExpiry );

   551     }

   552 

   553 

   554 // ---------------------------------------------------------

   555 // CMmsHeaders::SetExpiryDate

   556 //

   557 // ---------------------------------------------------------

   558 //

   559 EXPORT_C void CMmsHeaders::SetExpiryDate( TInt64 aDate )

   560     {

   561     iExpiry = aDate;

   562     iExpiryAbs = ETrue;

   563     }

   564 

   565 // ---------------------------------------------------------

   566 // CMmsHeaders::ExpiryDate

   567 //

   568 // ---------------------------------------------------------

   569 // 

   570 EXPORT_C TInt64 CMmsHeaders::ExpiryDate()

   571     {

   572     return iExpiryAbs ? iExpiry : TInt64( 0 );

   573     }

   574 

   575 // ---------------------------------------------------------

   576 // CMmsHeaders::SetDeliveryTimeInterval

   577 //

   578 // ---------------------------------------------------------

   579 //

   580 EXPORT_C void CMmsHeaders::SetDeliveryTimeInterval( TInt aInterval )

   581     {

   582     iDelivery = aInterval;

   583     iDeliveryAbs = EFalse;

   584     }

   585 

   586 // ---------------------------------------------------------

   587 // CMmsHeaders::DeliveryTimeInterval

   588 //

   589 // ---------------------------------------------------------

   590 //

   591 EXPORT_C TInt CMmsHeaders::DeliveryTimeInterval()

   592     {

   593     return iDeliveryAbs ? 0 : I64LOW( iDelivery );

   594     }

   595 

   596 // ---------------------------------------------------------

   597 // CMmsHeaders::SetDeliveryDate

   598 //

   599 // ---------------------------------------------------------

   600 //

   601 EXPORT_C void CMmsHeaders::SetDeliveryDate( TInt64 aDate )

   602     {

   603     iDelivery = aDate;

   604     iDeliveryAbs = ETrue;

   605     }

   606 

   607 // ---------------------------------------------------------

   608 // CMmsHeaders::DeliveryDate

   609 //

   610 // ---------------------------------------------------------

   611 //

   612 EXPORT_C TInt64 CMmsHeaders::DeliveryDate()

   613     {

   614     return iDeliveryAbs ? iDelivery : TInt64( 0 );

   615     }

   616 

   617 // ---------------------------------------------------------

   618 // CMmsHeaders::SetTidL

   619 //

   620 // ---------------------------------------------------------

   621 //

   622 EXPORT_C void CMmsHeaders::SetTidL( const TDesC8& aCid )

   623     {

   624     // If New TID has length zero, TID is cleared

   625     if ( aCid.Length() == 0 )

   626         {

   627         delete iTID;

   628         iTID = NULL;

   629         }

   630     else

   631         {

   632         HBufC8 * newAttrib = aCid.AllocL();

   633         if ( newAttrib->Length() > KMaxHeaderStringLength )

   634             {

   635             newAttrib->Des().SetLength( KMaxHeaderStringLength );

   636             }

   637         delete iTID;

   638         iTID = newAttrib;

   639         }

   640     }

   641 

   642 // ---------------------------------------------------------

   643 // CMmsHeaders::ContentLocation

   644 //

   645 // ---------------------------------------------------------

   646 //

   647 

   648 EXPORT_C TPtrC8 CMmsHeaders::ContentLocation() const

   649     {

   650     return iContentLocation ? TPtrC8( *iContentLocation ) : TPtrC8();

   651     }

   652      

   653 // ---------------------------------------------------------

   654 // CMmsHeaders::SetContentLocationL

   655 //

   656 // ---------------------------------------------------------

   657 //

   658 EXPORT_C void CMmsHeaders::SetContentLocationL( const TDesC8& aURL )

   659     {

   660     HBufC8 * newAttrib = aURL.AllocL();

   661     if ( newAttrib->Length() > KMaxHeaderStringLength )

   662         {

   663         newAttrib->Des().SetLength( KMaxHeaderStringLength );

   664         }

   665     delete iContentLocation;

   666     iContentLocation = newAttrib;

   667     }

   668   

   669 // ---------------------------------------------------------

   670 // CMmsHeaders::Tid

   671 //

   672 // ---------------------------------------------------------

   673 //

   674 EXPORT_C TPtrC8 CMmsHeaders::Tid() const

   675     {

   676     return iTID ? TPtrC8( *iTID ) : TPtrC8();

   677     } 

   678 

   679 // ---------------------------------------------------------

   680 // CMmsHeaders::InternalizeL

   681 //

   682 // ---------------------------------------------------------

   683 //

   684 EXPORT_C void CMmsHeaders::InternalizeL( RMsvReadStream& aStream )

   685     {

   686 

   687     aStream >> iVersion;

   688     aStream >> iMsgType;

   689 

   690     iSubject = HBufC::NewL( aStream, KMaxHeaderStringLength );

   691     iTID = HBufC8::NewL( aStream, KMaxHeaderStringLength );

   692     aStream >> iDate;

   693 

   694     iSender = HBufC::NewL( aStream, KMaxHeaderStringLength );

   695     aStream >> iMsgClass;

   696 

   697     aStream >> iExpiry;

   698     iExpiryAbs = aStream.ReadInt8L();

   699     aStream >> iDelivery;

   700     iDeliveryAbs = aStream.ReadInt8L();

   701 

   702     aStream >> iPriority;

   703     aStream >> iSenderVisi;

   704 

   705     aStream >> iDelivReport;

   706     aStream >> iReadReply;

   707 

   708     iStart = aStream.ReadInt32L();

   709     iContentLocation = HBufC8::NewL( aStream, KMaxHeaderStringLength );

   710 

   711     aStream >> iMessageSize;

   712     aStream >> iReportAllowed;

   713     aStream >> iResponseStatus;

   714 

   715     iMessageId = HBufC8::NewL( aStream, KMaxHeaderStringLength );

   716     aStream >> iStatus;

   717 

   718     aStream >> iMaxImageWidth;

   719     aStream >> iMaxImageHeight;

   720 

   721     // Internalize fields which may have multiple values.

   722     InternalizeArrayL( *iToArray, aStream );

   723     InternalizeArrayL( *iCcArray, aStream );

   724     InternalizeArrayL( *iBccArray, aStream );

   725 

   726     TInt32 length = 0;

   727     length = aStream.ReadInt32L();

   728     

   729     if ( length > 0 )

   730         {

   731         iRootContentID = HBufC8::NewL( aStream, length );

   732         }

   733 

   734     length = aStream.ReadInt32L();

   735     if ( length > 0 )

   736         {

   737         iOperatorResponseText = HBufC::NewL( aStream, length );

   738         }

   739   

   740     TInt i;

   741     aStream >> iReadStatus;

   742     aStream >> iReplyCharging;

   743     aStream >> iReplyChargingDeadline;

   744     iReplyChargingAbs = aStream.ReadInt8L();

   745     aStream >> iReplyChargingSize;

   746     aStream >> length;

   747     if ( length > 0 )

   748         {

   749         iReplyChargingId = HBufC8::NewL( aStream, length );

   750         }

   751 

   752     aStream >> length;

   753           

   754     for ( i = 0; i < length ; i++ )

   755         {

   756         CMmsSendingChain* item = new( ELeave )CMmsSendingChain;

   757         CleanupStack::PushL( item );

   758         item->InternalizeL( aStream );

   759         User::LeaveIfError( iPreviouslySentArray.InsertInOrder( item, iLinearOrder ));

   760         CleanupStack::Pop( item ); // item is in member array now

   761         }

   762 

   763     iDistributionIndicator = aStream.ReadInt32L();

   764 

   765     iRelatedEntry = aStream.ReadInt32L();

   766     iMultipartType = aStream.ReadInt32L();

   767     

   768     TInt64 tempTime;

   769     aStream >> tempTime;

   770     iReceivingTime = TTime( tempTime );

   771      

   772     iContentClass = aStream.ReadInt32L();

   773     iDrmContent = aStream.ReadInt32L();

   774     iAdaptationAllowed = aStream.ReadInt32L();

   775     }

   776 

   777 // ---------------------------------------------------------

   778 // CMmsHeaders::ExternalizeL

   779 //

   780 // ---------------------------------------------------------

   781 //

   782 EXPORT_C void CMmsHeaders::ExternalizeL( RMsvWriteStream& aStream ) const

   783     {

   784 

   785     // This MUST be the 1st item written into the stream    

   786     aStream << iVersion;

   787     // This must be 2nd. 

   788     aStream << iMsgType;

   789 

   790     aStream << LimitStringSize( Subject(), KMaxHeaderStringLength );

   791     aStream << LimitStringSize( Tid(), KMaxHeaderStringLength );

   792     aStream << iDate;

   793 

   794     aStream << LimitStringSize( Sender(), KMaxHeaderStringLength );

   795     aStream << iMsgClass;

   796 

   797     aStream << iExpiry;

   798     aStream.WriteInt8L( iExpiryAbs );

   799     aStream << iDelivery;

   800     aStream.WriteInt8L( iDeliveryAbs );

   801 

   802     aStream << iPriority;

   803     aStream << iSenderVisi;

   804 

   805     aStream << iDelivReport;

   806     aStream << iReadReply;

   807 

   808     aStream.WriteInt32L( iStart );

   809     aStream << LimitStringSize( ContentLocation(), KMaxHeaderStringLength );

   810 

   811     aStream << iMessageSize;

   812     aStream << iReportAllowed;

   813     aStream << iResponseStatus;

   814 

   815     aStream << LimitStringSize( MessageId(), KMaxHeaderStringLength );

   816     aStream << iStatus;

   817 

   818     aStream << iMaxImageWidth;

   819     aStream << iMaxImageHeight;

   820 

   821     // Externalize fields which may have multiple values.

   822     ExternalizeArrayL( *iToArray, aStream );

   823     ExternalizeArrayL( *iCcArray, aStream );

   824     ExternalizeArrayL( *iBccArray, aStream );

   825 

   826     TInt32 length;

   827     length = RootContentId().Length();

   828     aStream << length;

   829     if ( length > 0 )

   830         {

   831         aStream << RootContentId();

   832         }

   833     length = ResponseText().Length();

   834     aStream << length;

   835     if ( length > 0 )

   836         {

   837         aStream << ResponseText();

   838         }

   839 

   840     TInt i;

   841     aStream << iReadStatus;

   842     aStream << iReplyCharging;

   843     aStream << iReplyChargingDeadline;

   844     aStream.WriteInt8L( iReplyChargingAbs );

   845     aStream << iReplyChargingSize;

   846     length = ReplyChargingId().Length();

   847     aStream << length;

   848     if ( length > 0 )

   849         {

   850         aStream << ReplyChargingId();

   851         }

   852 

   853     length = iPreviouslySentArray.Count();

   854     aStream << length;

   855     for ( i = 0; i < iPreviouslySentArray.Count(); i++ )

   856         {

   857         iPreviouslySentArray[ i ]->ExternalizeL( aStream );

   858         }

   859 

   860     aStream.WriteInt32L( iDistributionIndicator );

   861     aStream.WriteInt32L( iRelatedEntry );

   862     aStream.WriteInt32L( iMultipartType );

   863     

   864     aStream << iReceivingTime.Int64();

   865     

   866     aStream.WriteInt32L( iContentClass );

   867     aStream.WriteInt32L( iDrmContent );

   868     aStream.WriteInt32L( iAdaptationAllowed );

   869 

   870     }

   871 

   872 // ---------------------------------------------------------

   873 // CMmsHeaders::ElementDescriptorL

   874 //

   875 // ---------------------------------------------------------

   876 //

   877 EXPORT_C CMmsElementDescriptor& CMmsHeaders::ElementDescriptorL()

   878     {

   879     if ( !iElementDescriptor )

   880         {

   881         iElementDescriptor = new( ELeave )CMmsElementDescriptor;

   882         }

   883     return *iElementDescriptor;

   884     }

   885 

   886 // ---------------------------------------------------------

   887 // CMmsHeaders::MMBoxMessageHeadersL

   888 //

   889 // ---------------------------------------------------------

   890 //

   891 EXPORT_C CMmsMMBoxMessageHeaders& CMmsHeaders::MMBoxMessageHeadersL()

   892     {

   893     if ( !iMmBoxMessageHeaders )

   894         {

   895         iMmBoxMessageHeaders = CMmsMMBoxMessageHeaders::NewL();

   896         }

   897     return *iMmBoxMessageHeaders;

   898     }

   899 

   900 // ---------------------------------------------------------

   901 // CMmsHeaders::MMBoxViewHeadersL

   902 //

   903 // ---------------------------------------------------------

   904 //

   905 EXPORT_C CMmsMMBoxViewHeaders& CMmsHeaders::MMBoxViewHeadersL()

   906     {

   907     if ( !iMmBoxViewHeaders )

   908         {

   909         iMmBoxViewHeaders = new( ELeave )CMmsMMBoxViewHeaders;

   910         }

   911     return *iMmBoxViewHeaders;

   912     }

   913 

   914 // ---------------------------------------------------------

   915 // CMmsHeaders::SetExtendedNotificationL

   916 //

   917 // ---------------------------------------------------------

   918 //

   919 EXPORT_C void CMmsHeaders::SetExtendedNotificationL( const TDesC& aText )

   920     {

   921     HBufC* newAttrib = NULL;

   922     if ( aText.Length() > 0 )

   923         {

   924         newAttrib = aText.AllocL();

   925         }

   926     delete iExtendedNotificationText;

   927     iExtendedNotificationText = newAttrib;

   928     }

   929 

   930 // ---------------------------------------------------------

   931 // CMmsHeaders::ExtendedNotification

   932 //

   933 // ---------------------------------------------------------

   934 //

   935 EXPORT_C TPtrC CMmsHeaders::ExtendedNotification() const

   936     {

   937     return iExtendedNotificationText ? TPtrC( *iExtendedNotificationText ) : TPtrC();

   938     }

   939 

   940 // ---------------------------------------------------------

   941 // CMmsHeaders::RemoveAddressee

   942 //

   943 // ---------------------------------------------------------

   944 //

   945 TBool CMmsHeaders::RemoveAddressee(

   946     CDesCArray& aList,

   947     const TDesC& aAddress )

   948     {

   949 

   950     TInt count = aList.Count();

   951     TInt i;

   952 

   953     // We must compare only pure addresses.

   954     // The list may contain addresses that include aliases.    

   955     for ( i = count - 1; i >= 0; i-- )

   956         {

   957         if ( TMmsGenUtils::PureAddress( aAddress ).CompareF(

   958             TMmsGenUtils::PureAddress( aList.MdcaPoint( i ) ) ) == 0 )

   959             {

   960             aList.Delete( i );

   961             aList.Compress();

   962             return ETrue;

   963             }

   964         }

   965 

   966     return EFalse;

   967     }

   968 

   969 // ---------------------------------------------------------

   970 // CMmsHeaders::Reset

   971 //

   972 // ---------------------------------------------------------

   973 //

   974 EXPORT_C void CMmsHeaders::Reset( CMmsSettings* aSettings )

   975     {

   976 

   977     iMsgType = 0;

   978     

   979     delete iTID;

   980     iTID = NULL;

   981 

   982     // Always restore the default version - even if not reading other settings

   983     iVersion = iMmsDefaultVersion;  

   984     iDate = 0;    

   985 

   986     delete iSender;

   987     iSender = NULL;

   988 

   989     iToArray->Reset();

   990     iCcArray->Reset(); 

   991     iBccArray->Reset(); 

   992 

   993     delete iSubject;   

   994     iSubject = NULL;

   995 

   996     iMsgClass = 0;  

   997 

   998     iExpiry = 0;    

   999     iExpiryAbs = 0; 

  1000     iDelivery = 0;  

  1001     iDeliveryAbs = 0;

  1002     iPriority = 0;  

  1003     iSenderVisi = 0;

  1004     iDelivReport = 0;

  1005     iReadReply = 0;

  1006     iStart = KMsvNullIndexEntryId; 

  1007 

  1008     delete iContentLocation; 

  1009     iContentLocation = NULL;

  1010 

  1011     iMessageSize = 0;

  1012     iReportAllowed = 0;  

  1013     iResponseStatus = 0; 

  1014 

  1015     delete iMessageId; 

  1016     iMessageId = NULL;

  1017 

  1018     iStatus = 0;

  1019 

  1020     iMaxImageHeight = 0;

  1021     iMaxImageWidth = 0;

  1022 

  1023     delete iOperatorResponseText;

  1024     iOperatorResponseText = NULL;

  1025 

  1026     delete iRootContentID;

  1027     iRootContentID = NULL;

  1028 

  1029     iReadStatus = 0;

  1030     iReplyCharging = 0;

  1031     iReplyChargingDeadline = 0;

  1032     iReplyChargingAbs = EFalse;

  1033     delete iReplyChargingId;

  1034     iReplyChargingId = NULL;

  1035     iReplyChargingSize = 0;

  1036     iPreviouslySentArray.ResetAndDestroy();

  1037     iDeleteResultArray.ResetAndDestroy();

  1038 

  1039     iDistributionIndicator = 0;

  1040     iRelatedEntry = 0;

  1041     iMultipartType = 0;

  1042     iReceivingTime = 0;

  1043     // encapsulation 1.3 headers

  1044     iContentClass = 0;

  1045     iDrmContent = 0;

  1046     iAdaptationAllowed = 0;

  1047 

  1048     delete iElementDescriptor;

  1049     iElementDescriptor = NULL;

  1050     delete iMmBoxMessageHeaders;

  1051     iMmBoxMessageHeaders = NULL;

  1052     delete iMmBoxViewHeaders;

  1053     iMmBoxViewHeaders = NULL;

  1054 

  1055     delete iExtendedNotificationText;

  1056     iExtendedNotificationText = NULL;

  1057 

  1058     iExtensionStatus = 0; // set unknown status

  1059     

  1060     delete iApplicationId;

  1061     iApplicationId = NULL;

  1062     delete iReplyToApplicationId;

  1063     iReplyToApplicationId = NULL;

  1064     delete iApplicationInfo;

  1065     iApplicationInfo = NULL;

  1066     

  1067     iRecommendedRetrievalMode = 0;

  1068     delete iRecommendedRetrievalModeText;

  1069     iRecommendedRetrievalModeText = NULL;

  1070     delete iReplaceCancelId; 

  1071     iReplaceCancelId = NULL; 

  1072     iCancelStatus = 0;

  1073     

  1074     SetSettings( aSettings );

  1075     

  1076     }

  1077 

  1078 // ---------------------------------------------------------

  1079 // CMmsHeaders::Size

  1080 //

  1081 // ---------------------------------------------------------

  1082 //

  1083 EXPORT_C TInt CMmsHeaders::Size() const

  1084     {

  1085 

  1086     TInt size = sizeof( iMsgType );

  1087 

  1088     size+= Tid().Size();

  1089 

  1090     size+= sizeof( iVersion );

  1091 

  1092     size+= sizeof( iDate );

  1093 

  1094     TInt i;

  1095 

  1096     TInt nbr = iToArray->MdcaCount();

  1097     for ( i=0; i < nbr; ++i )

  1098         {

  1099         size += iToArray->MdcaPoint(i).Size();

  1100         }

  1101 

  1102     nbr = iCcArray->MdcaCount();

  1103     for ( i=0; i < nbr; ++i )

  1104         {

  1105         size+=iCcArray->MdcaPoint(i).Size();

  1106         }

  1107 

  1108     nbr = iBccArray->MdcaCount();

  1109     for ( i=0; i < nbr; ++i )

  1110         {

  1111         size+=iBccArray->MdcaPoint(i).Size();

  1112         }

  1113 

  1114     size+= Sender().Size();

  1115 

  1116     size+= Subject().Size();

  1117     

  1118     size+= sizeof( iMsgClass );

  1119 

  1120     size+= sizeof( iExpiry );

  1121 

  1122     size+= sizeof( iExpiryAbs );

  1123 

  1124     size+= sizeof( iDelivery );

  1125 

  1126     size+= sizeof( iDeliveryAbs );

  1127 

  1128     size+= sizeof( iPriority );

  1129 

  1130     size+= sizeof( iSenderVisi );

  1131 

  1132     size+= sizeof( iDelivReport );

  1133 

  1134     size+= sizeof( iReadReply );