/*

* Copyright (c) 2004 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:  

*      Entry wrapper implementing MMmsEntry for client side.

*      Hides difference between CMscEntry and CMsvServerEntry

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <msventry.h>

#include    <msvstd.h>

#include    <msvapi.h> //Message Server

#include    <badesca.h>

#include    <cmsvmimeheaders.h>

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include    <centralrepository.h>

#include    "mmscliententry.h"

#include    "MmsEnginePrivateCRKeys.h"

#include    "mmsheaders.h"

#include    "mmsattachmenthandler.h"

#include    "mmsgenutils.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// 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.

//

CMmsClientEntry::CMmsClientEntry( RFs& aFs, CMsvEntry& aEntry ):

    iFs ( aFs ),

    iCMsvEntry ( aEntry )

    {

    }

// EPOC default constructor can leave.

void CMmsClientEntry::ConstructL( TMsvId aServiceId  )

    {

    iServiceId = aServiceId;

    iMessageEntry = iCMsvEntry.EntryId();

    if ( iMessageEntry == iServiceId )

        {

        iMessageEntry = KMsvNullIndexEntryId;

        }

    iMessageDrive = iCMsvEntry.Session().CurrentDriveL();

    TMmsGenUtils::GetLoggingSettings( iLogAllDecoded, iDump );

    }

// Two-phased constructor.

EXPORT_C CMmsClientEntry* CMmsClientEntry::NewL( RFs& aFs, CMsvEntry& aEntry, TMsvId aServiceId )

    {

    CMmsClientEntry* self = new (ELeave) CMmsClientEntry(aFs, aEntry );

    CleanupStack::PushL( self );

    self->ConstructL( aServiceId );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMmsClientEntry::~CMmsClientEntry()

    {

    if ( iFileOpen )

        {

        iAttaFile.Close();

        iFileOpen = EFalse;

        }

    }

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

// CMmsClientEntry::EditStoreL

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

//

CMsvStore* CMmsClientEntry::EditStoreL()

    {

    return iCMsvEntry.EditStoreL();

    }

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

// CMmsClientEntry::ReadStoreL

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

//

CMsvStore* CMmsClientEntry::ReadStoreL()

    {

    return iCMsvEntry.ReadStoreL();

    }

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

// CMmsClientEntry::GetIndexEntry

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

//

TInt CMmsClientEntry::GetIndexEntry( TMsvEntry& aTMsvEntry )

    {

    if ( iMessageEntry == KMsvNullIndexEntryId )

        {

        return KErrNotFound;

        }

    aTMsvEntry = iCMsvEntry.Entry();

    return KErrNone;

    }

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

// CMmsClientEntry::ChangeIndexEntry

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

//

TInt CMmsClientEntry::ChangeIndexEntry( TMsvEntry& aTMsvEntry )

    {

    if ( iMessageEntry == KMsvNullIndexEntryId )

        {

        return KErrNotFound;

        }

    TRAPD( error, iCMsvEntry.ChangeL( aTMsvEntry ) );

    return error;

    }

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

// CMmsClientEntry::SetContext

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

//

TInt CMmsClientEntry::SetCurrentEntry( TMsvId aEntryId )

    {

    if ( iMessageEntry == aEntryId && iCMsvEntry.Entry().Id() == aEntryId )

        {

        // we already have the context

        return KErrNone;

        }

    TRAPD( error, iCMsvEntry.SetEntryL( aEntryId ) );

    if ( error == KErrNone )

        {

        iMessageEntry = aEntryId;

        }

    else

        {

        iMessageEntry = KMsvNullIndexEntryId;

        }

    return error;

    }

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

// CMmsClientEntry::AttachmentsSize

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

//

TInt CMmsClientEntry::AttachmentsSizeL( CMsvStore& aStore )

    {

    return CMmsAttachmentHandler::AttachmentsSizeL( aStore );

    }

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

// CMmsClientEntry::DiskSpaceBelowCriticalLevelL

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

//

TInt CMmsClientEntry::DiskSpaceBelowCriticalLevelL( TInt aDataSize )

    {

    TInt error = KErrNone;

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(

        &iFs, aDataSize, iMessageDrive ) )

        {

        error = KErrDiskFull;

        }

    return error;

    }

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

// CMmsClientEntry::

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

//

TInt CMmsClientEntry::StoreMmsHeadersL( CMmsHeaders& aMmsHeaders, CMsvStore* aStore )

    {

    TInt error = KErrNone;

    if ( DiskSpaceBelowCriticalLevelL( aMmsHeaders.Size() ) )

        {

        error = KErrDiskFull;

        }

    if ( error == KErrNone )

        {

        CMsvStore* store = aStore;

        if ( !aStore )

            {

            store = iCMsvEntry.EditStoreL();

            CleanupStack::PushL( store );

            }

        aMmsHeaders.StoreL( *store );

        if ( !aStore )

            {

            store->CommitL();

            CleanupStack::PopAndDestroy( store );

            }

        }

    return error;

   }

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

// CMmsClientEntry::

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

//

void CMmsClientEntry::RestoreMmsHeadersL( CMmsHeaders& aMmsHeaders, CMsvStore* aStore )

    {

    // The entry must be kept pointing to the message entry

    // As all attachment are stored to the message enrty, it is

    // no longer necessary to switch the context between message

    // entry and attachment entry.

    CMsvStore* store = aStore;

    if ( !aStore )

        {

        store = iCMsvEntry.ReadStoreL();

        CleanupStack::PushL( store );

        }

    aMmsHeaders.RestoreL( *store );

    if ( !aStore )

        {

        CleanupStack::PopAndDestroy( store );

        }

    }

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

// CMmsClientEntry::

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

//

TInt CMmsClientEntry::CreateFileAttachmentL(

            CMsvStore& aStore,

            const TDesC& aFileName,

            const TPtrC8& aAttachmentData,

            CMsvMimeHeaders& aMimeHeaders,

            TMsvAttachmentId& aAttachment,

            TInt& aAttachmentSize,

            TInt32& aDRMFlags )

    {

    TInt error = KErrNone;

    CreateEmptyFileAttachmentL(

        aStore,

        aFileName,

        aMimeHeaders,

        aAttachment );

    error = ProcessAttachmentDataL( aAttachmentData, aDRMFlags );

    TInt error2 = KErrNone;

    error2 = FinalizeAttachmentL( aStore, aAttachmentSize, aDRMFlags );

    if ( error == KErrNone )

        {

        error = error2;

        }

    return error;

    }

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

// CMmsClientEntry::

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

//

TInt CMmsClientEntry::DeleteEntry( TMsvId aEntryIndex )

    {

    TInt error = KErrNone;

    TRAP( error,

        {

        iCMsvEntry.SetEntryL( aEntryIndex );

        iCMsvEntry.SetEntryL( iCMsvEntry.Entry().Parent() );

        iCMsvEntry.DeleteL( aEntryIndex );

        } )

    if ( error == KErrNotFound )

        {

        error = KErrNone;

        }

    iMessageEntry = KMsvNullIndexEntryId;

    return error;

    }

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

// CMmsClientEntry::

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

//

TBool CMmsClientEntry::IsValidFilename(

            const TPtrC& aFileName )

    {

    return CMmsAttachmentHandler::IsValidFilename( iFs, aFileName );

    }

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

// CMmsClientEntry::

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

//

TBool CMmsClientEntry::GetDecodingFlag()

    {

    return iLogAllDecoded;

    }

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

// CMmsClientEntry::

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

//

TBool CMmsClientEntry::GetDumpFlag()

    {

    return iDump;

    }

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

// CMmsClientEntry::

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

//

void CMmsClientEntry::CreateEmptyFileAttachmentL(

    CMsvStore& aStore,

    const TDesC& aFileName,

    CMsvMimeHeaders& aMimeHeaders,

    TMsvAttachmentId& aAttachment)

    {

    iAttaId = 0;

    if ( iFileOpen )

        {

        iAttaFile.Close();

        iFileOpen = EFalse;

        }

    // store must be created before attachmentInfo because attachment info ownership

    // will be transferred to attachment manager

    CMsvAttachment* attachmentInfo = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );

    CleanupStack::PushL( attachmentInfo );

    attachmentInfo->SetAttachmentNameL( aFileName );

    // We must set size after the data has been saved

    attachmentInfo->SetComplete( ETrue );

    // take type from mime headers

    HBufC8* tempContentType = HBufC8::NewL( aMimeHeaders.ContentType().Length() +

       aMimeHeaders.ContentSubType().Length() + 1 );

    CleanupStack::PushL( tempContentType );

    tempContentType->Des().Copy( aMimeHeaders.ContentType() );

    tempContentType->Des().Append( KMmsSlash8 );

    tempContentType->Des().Append( aMimeHeaders.ContentSubType() );

    attachmentInfo->SetMimeTypeL( tempContentType->Des() );

    CleanupStack::PopAndDestroy( tempContentType );

    aMimeHeaders.StoreL( *attachmentInfo ); // Mime headers are streamed into atta info

    if ( DiskSpaceBelowCriticalLevelL( aMimeHeaders.Size() ) )

        {

        // attachmentInfo ownership was not transferred - it must be destroyed

        CleanupStack::PopAndDestroy( attachmentInfo );

        User::Leave( KErrDiskFull );

        }

    MMsvAttachmentManagerSync& attaMan = aStore.AttachmentManagerExtensionsL();

    attaMan.CreateAttachmentL( aFileName, iAttaFile, attachmentInfo );

    CleanupStack::Pop( attachmentInfo ); // attachmentInfo ownership was transferred.

    aAttachment = attachmentInfo->Id();

    iAttaId = aAttachment;

    iFileOpen = ETrue;

    }

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

// CMmsClientEntry::

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

//

TInt CMmsClientEntry::ProcessAttachmentDataL(

    const TPtrC8& aAttachmentData,

    TInt32& /*aDRMFlags*/ )

    {

    if ( DiskSpaceBelowCriticalLevelL( aAttachmentData.Size() ) )

        {

        return KErrDiskFull;

        }

    else

        {

        return iAttaFile.Write( aAttachmentData );

        }

    }

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

// CMmsClientEntry::

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

//

TInt CMmsClientEntry::FinalizeAttachmentL(

    CMsvStore& aStore,

    TInt& aAttachmentSize,

    TInt32& /*aDRMFlags*/ )

    {

    TInt error = KErrNone;

    TInt size = 0;

    if ( iFileOpen )

        {

        error = iAttaFile.Flush();

        iAttaFile.Size( size );

        }

    aAttachmentSize = size;

    if ( iFileOpen )

        {

        iAttaFile.Close();

        iFileOpen = EFalse;

        }

    MMsvAttachmentManager& attaMan = aStore.AttachmentManagerL();

    MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();

    if ( size == 0 )

        {

        // if file was not open, open it and get the size

        RFile handle = attaMan.GetAttachmentFileL( iAttaId );

        handle.Size( size );            

        handle.Close();

        }

    CMsvAttachment* attachmentInfo = attaMan.GetAttachmentInfoL( iAttaId );

    CleanupStack::PushL( attachmentInfo );

    attachmentInfo->SetSize( size );

    TRAPD( error2, attaManSync.ModifyAttachmentInfoL( attachmentInfo ) );

    if ( error2 == KErrNone )

        {

        CleanupStack::Pop( attachmentInfo ); // attachmentInfo ownership was transferred.

        }

    else

        {

        // if error, attachmentinfo ownership was not transferred

        CleanupStack::PopAndDestroy( attachmentInfo );

        }

    // Error about unsuccessful attachment info modification is not returned to caller.

    // The attachment size info is unreliable anyway, actual file size should always be called

    return error;

    }

// ================= OTHER EXPORTED FUNCTIONS ==============

//  End of File