/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: mmsheaders implementation

*

*/

// INCLUDE FILES

#include    <msvstore.h>

#include    <badesca.h>

#include    <msvids.h>

#include    <mtmdef.h>

#include    <e32def.h>

#include    <e32math.h>

#include    <mmsvattachmentmanager.h>

#include    <cmsvmimeheaders.h>

#include    "mmsconst.h"

#include    "mmsheaders.h"

#include    "mmssettings.h"

#include    "mmsversion.h"

#include    "mmselementdescriptor.h"

#include    "mmsmmboxmessageheaders.h"

#include    "mmsmmboxviewheaders.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KMmsArrayAllocationNumber = 6;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

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

// might leave.

//

CMmsHeaders::CMmsHeaders():

    iLinearOrder( CMmsSendingChain::Compare ),

    iDeleteResultOrder( CMmsDeleteResultArray::Compare )

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

    {

    }

// Symbian OS default constructor can leave.

void CMmsHeaders::ConstructL( TInt16 aMmsDefaultVersion )

    {

    iToArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    iCcArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    iBccArray = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    iMmsDefaultVersion = aMmsDefaultVersion;

    if ( iMmsDefaultVersion < KMmsMinimumSupportedVersion ||

        iMmsDefaultVersion > KMmsMaximumSupportedVersion )

        {

        // The supported default version must be within limits.

        // The actual messages can carry any version

        iMmsDefaultVersion = KMmsDefaultVersion;

        }

    Reset( NULL );

    }

// Two-phased constructor.

EXPORT_C CMmsHeaders* CMmsHeaders::NewL( TInt16 aMmsVersion )

    {

    CMmsHeaders* self = new ( ELeave ) CMmsHeaders;

    CleanupStack::PushL( self );

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

    self->ConstructL( aMmsVersion );

    CleanupStack::Pop( self );

    return self;

    }

// Two-phased constructor.

EXPORT_C CMmsHeaders* CMmsHeaders::NewL()

    {

    CMmsHeaders* self = new ( ELeave ) CMmsHeaders;

    CleanupStack::PushL( self );

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

    self->ConstructL( KMmsDefaultVersion );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMmsHeaders::~CMmsHeaders()

    {

    iPreviouslySentArray.ResetAndDestroy();

    iDeleteResultArray.ResetAndDestroy();

    delete iOperatorResponseText;

    delete iReplyChargingId;

    delete iToArray;

    delete iCcArray;

    delete iBccArray;

    delete iSender;

    delete iContentLocation;

    delete iSubject;

    delete iTID;

    delete iMessageId;

    delete iRootContentID;

    delete iElementDescriptor;

    delete iMmBoxMessageHeaders;

    delete iMmBoxViewHeaders;

    delete iExtendedNotificationText;

    delete iApplicationId;

    delete iReplyToApplicationId;

    delete iApplicationInfo;

    delete iRecommendedRetrievalModeText;

    delete iReplaceCancelId;

    }

// ---------------------------------------------------------

// CMmsHeaders::RestoreL

//

// ---------------------------------------------------------

//

EXPORT_C void CMmsHeaders::RestoreL(

    CMsvStore& aStore )

    {

    RMsvReadStream stream;

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

    if ( aStore.IsPresentL( KUidMmsHeaderStream ) )

        {

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

        InternalizeL( stream );

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

        }

    // restore MMBox header streams if present

    if ( aStore.IsPresentL( KUidMMsElementDescriptorStream ) )

        {

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

        iElementDescriptor = new( ELeave )CMmsElementDescriptor;

        iElementDescriptor->InternalizeL( stream );

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

        }

    if ( aStore.IsPresentL( KUidMMsMMBoxMessageHeaderStream ) )

        {

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

        iMmBoxMessageHeaders = CMmsMMBoxMessageHeaders::NewL();

        iMmBoxMessageHeaders->InternalizeL( stream );

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

        }

    if ( aStore.IsPresentL( KUidMMsMMBoxViewHeadersStream ) )

        {

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

        iMmBoxViewHeaders = new( ELeave )CMmsMMBoxViewHeaders;

        iMmBoxViewHeaders->InternalizeL( stream );

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

        }

    // Extended notification also restored here

    TInt length = 0; // string length

    // Completeness indicator is not saved or restored.

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

    if ( aStore.IsPresentL( KUidMMsExtendedNotificationStream ) )

        {

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

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

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

        }

    if ( aStore.IsPresentL( KUidMmsApplicationInfoStream ) )

        {

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

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

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

        }

    if ( aStore.IsPresentL( KUidMmsReserved ) )

        {

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

        iRecommendedRetrievalMode = stream.ReadInt32L();

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

        length = stream.ReadInt32L();

        if ( length > 0 )

            {

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

            }

        iCancelStatus = stream.ReadInt32L();

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

        }

    } 

// ---------------------------------------------------------

// CMmsEntry::StoreL

//

// ---------------------------------------------------------

//

EXPORT_C void CMmsHeaders::StoreL(

    CMsvStore& aStore )

    {

    // Check if message root is correctly set

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

    if ( iStart != 0 )

        {

        MMsvAttachmentManager& attaMan = aStore.AttachmentManagerL();

        CMsvAttachment* attaInfo = NULL;

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

        if ( error == KErrNotFound )

            {

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

            iStart = 0;

            delete iRootContentID;

            iRootContentID = 0;

            }

        else if ( error == KErrNone )

            {

            // got the attachment, check content id

            CleanupStack::PushL( attaInfo );

            CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

            CleanupStack::PushL( mimeHeaders );

            mimeHeaders->RestoreL( *attaInfo );

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

                {

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

                    {

                    // mime headers win

                    SetRootContentIdL( mimeHeaders->ContentId() );

                    }

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

                    {

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

                    mimeHeaders->SetContentIdL( RootContentId() );

                    mimeHeaders->StoreL( *attaInfo );

                    }

                else

                    {

                    // keep LINT happy

                    }

                }

            CleanupStack::PopAndDestroy( mimeHeaders );

            CleanupStack::PopAndDestroy( attaInfo );

            }

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

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

        else

            {

            // Keep LINT happy.

            }

        }

    // caller must commit the store

    RMsvWriteStream stream;

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

    ExternalizeL( stream );

    stream.CommitL();

    stream.Close();

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

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

    if ( iElementDescriptor )

        {

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

        iElementDescriptor->ExternalizeL( stream );

        stream.CommitL();

        stream.Close();

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

        }

    if ( iMmBoxMessageHeaders )

        {

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

        iMmBoxMessageHeaders->ExternalizeL( stream );

        stream.CommitL();

        stream.Close();

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

        }

    if ( iMmBoxViewHeaders )

        {

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

        iMmBoxViewHeaders->ExternalizeL( stream );

        stream.CommitL();

        stream.Close();

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

        }

    TInt length = 0; // 

    // store extended notification if present

    if ( iExtendedNotificationText )

        {

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

        length = ExtendedNotification().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << ExtendedNotification();

            }

        stream.CommitL();

        stream.Close();

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

        }

    if ( iApplicationId ||

        iReplyToApplicationId ||

        iApplicationInfo )

        {

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

        length = ApplicId().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << iApplicationId->Des();

            }

        length = ReplyApplicId().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << iReplyToApplicationId->Des();

            }

        length = AuxApplicInfo().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << iApplicationInfo->Des();

            }

        stream.CommitL();

        stream.Close();

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

        }

    // reserved transaction info stream

    if ( iRecommendedRetrievalMode != 0 ||

        iRecommendedRetrievalModeText ||

        iReplaceCancelId ||

        iCancelStatus != 0 )

        {

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

        stream.WriteInt32L( iRecommendedRetrievalMode );

        length = RecommendedRetrievalModeText().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << iRecommendedRetrievalModeText->Des();

            }

        length = ReplaceCancelId().Length();

        stream.WriteInt32L( length );

        if ( length > 0 )

            {

            stream << iReplaceCancelId->Des();

            }

        stream.WriteInt32L( iCancelStatus );

        stream.CommitL();

        stream.Close();

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

        }

    }

// ---------------------------------------------------------

// CMmsHeaders::TypedAddresseeList

//

// ---------------------------------------------------------

//

EXPORT_C const CDesCArray& CMmsHeaders::TypedAddresseeList( 

    TMmsRecipients aType ) 

    {

    TInt type = aType;

    if (type == EMmsTo)

        {

        return *iToArray;

        }

    else if ( type == EMmsCc )

        {

        return *iCcArray;

        }

    else 

        {

        return *iBccArray;

        }

    }

// ---------------------------------------------------------

// CMmsHeaders::AddTypedAddresseeL

//

// ---------------------------------------------------------

//

EXPORT_C void CMmsHeaders::AddTypedAddresseeL( 

    const TDesC&  aRealAddress, 

    TMmsRecipients aType  )

    {

    TInt type = aType;

    if ( type == EMmsTo )

        {

        iToArray->AppendL( aRealAddress );

        }

    if ( type == EMmsCc )

        {

        iCcArray->AppendL( aRealAddress );

        }

    if ( type == EMmsBcc ) 

        {

        iBccArray->AppendL( aRealAddress );

        }

    }

// ---------------------------------------------------------

// CMmsHeaders::RemoveAddresseeL

//

// ---------------------------------------------------------

//

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

    {

    if ( RemoveAddressee( *iToArray, aRealAddress) )

        {

        return ETrue;

        }

    if ( RemoveAddressee( *iCcArray, aRealAddress) )

        {

        return ETrue;

        }

    if ( RemoveAddressee( *iBccArray, aRealAddress) )

        {

        return ETrue;

        }

    return EFalse;

    }

// ---------------------------------------------------------

// CMmsHeaders::SetSubjectL

//

// ---------------------------------------------------------

//

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

    {

    HBufC* newAttrib = aSubject.AllocL();

    delete iSubject;

    iSubject = newAttrib;

    }

// ---------------------------------------------------------

// CMmsHeaders::Subject

//

// ---------------------------------------------------------

//

EXPORT_C TPtrC CMmsHeaders::Subject() const

    {

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

    }

// ---------------------------------------------------------

// CMmsHeaders::SetSenderL

//

// ---------------------------------------------------------

//

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

    {

    HBufC* newAttrib = aAlias.AllocL();

    delete iSender;

    iSender = newAttrib;

    }

// ---------------------------------------------------------

// CMmsHeaders::Sender

//

// ---------------------------------------------------------

//

EXPORT_C TPtrC CMmsHeaders::Sender() const

    {

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