/*

* Copyright (c) 2003 - 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:   Provides access to message store.

*

*/

// INCLUDE FILES

#include "mmsheaders.h"

#include "mmscodecclient.h"

#include "mmsversion.h"

#include "mmsmsventry.h" // for the TMmsMsvEntry

#include "mmsgenutils.h"

#include "mmssettings.h"

#include "mmsdecode.h"

#include "mmsencode.h"

#include "mmscliententry.h"

#include "mmsclient.h"

#include "mmscodecclientlogger.h"

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include    <mtclreg.h>     //CClientMtmRegistry

#include    <msvapi.h>         // CMsvOperation 

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt  KMaxDetailsLength = 64;   // Copy max this many chars to TMsvEntry

                                      //::iDetails

_LIT( KAddressSeparator, ";" );       //Separator used between addresses in 

                                      //TMsvEntry::iDetails

const TInt KMmsCodecClientChunkSize = 10 * 1024; // 10k buffer - can be adjusted if needed

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMmsCodecClient::CMmsCodecClient

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

//

CMmsCodecClient::CMmsCodecClient():CActive( EPriorityStandard ),

    iEntryBeingHandled ( KMsvNullIndexEntryId ),

    iFolder ( KMsvNullIndexEntryId ),

    iMmsVersion ( KMmsDefaultVersion ),

    iState ( EIdle )

    {     

    }

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

// CMmsCodecClient::ConstructL

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

//

void CMmsCodecClient::ConstructL( CMsvSession& aMsvSession )

    {

    iMsvSession = &aMsvSession; 

    iFs = iMsvSession->FileSession();

    iClientEntry = iMsvSession->GetEntryL( KMsvRootIndexEntryId );   

    iMmsHeaders = CMmsHeaders::NewL( KMmsDefaultVersion );

    iDecoder = CMmsDecode::NewL( iFs );

    iEncoder = CMmsEncode::NewL( iFs );

    iClientMtmRegistry = CClientMtmRegistry::NewL( *iMsvSession );

    iMmsClient = (CMmsClientMtm *) iClientMtmRegistry->NewMtmL( 

        KUidMsgTypeMultimedia );

    iClientEntryWrapper = CMmsClientEntry::NewL( iFs, *iClientEntry, EFalse );

    CMmsSettings* settings = CMmsSettings::NewL();

    CleanupStack::PushL( settings );

    settings->LoadSettingsL();

    iMmsVersion = settings->MmsVersion();

    CleanupStack::PopAndDestroy( settings );

    CActiveScheduler::Add( this );

    }

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

// CMmsCodecClient::NewL

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

//

EXPORT_C CMmsCodecClient* CMmsCodecClient::NewL( CMsvSession& aMsvSession )

    {

    CMmsCodecClient* self = new( ELeave ) CMmsCodecClient;

    CleanupStack::PushL( self );

    self->ConstructL( aMsvSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMmsCodecClient::~CMmsCodecClient()

    { 

    // from CActive

    Cancel();

    // If we come to destructor before all the member variables have been created,

    // iState == EIdle, and none of the cleanup operations are attempted (pointers

    // not used before they are created).

    // By the time iState is something else besides idle, all member pointers exist

    // already and can be used.

    // Cleanup after incomplete operation

    ResetChunkedMode();

    //Let's make sure that if entry has just been created

    //it is be deleted.

    // we also check if iClientEntryWrapper is not NULL,

    // but actually, if is null, iState is idle.

    if ( iClientEntryWrapper &&

        ( iState == EEntryCreated || iState == EChunkedAdd || iState == EChunkedReplace ) &&

        iEntryBeingHandled != KMsvNullIndexEntryId ) 

        {

        iClientEntryWrapper->DeleteEntry( iEntryBeingHandled ); 

        }

    delete iMmsHeaders;

    delete iDecoder;

    delete iEncoder;

    delete iClientEntryWrapper;

    delete iClientEntry; 

    delete iMmsClient;

    delete iClientMtmRegistry;

    delete iEncodeBuffer;

    }

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

// CMmsCodecClient::AddMML

// This function is called after CreateNewMessageEntryL so the new created id

// aMmId already exist.

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

//

EXPORT_C void CMmsCodecClient::AddMML(

    CBufFlat& aMm,

    TMsvId aFolder,

    TUint32 aFlags,

    TBool aUnread,

    TMsvId& aMmId,

    TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;   

    iEntryBeingHandled = aMmId;

    iFolder = aFolder;

    iFlags = aFlags;

    iUnread = aUnread;

    //The entry must have just been created

    if ( iState != EEntryCreated )

        {

        ResetChunkedMode();

        iState = EIdle;

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );

        return;

        }

    // Check if the buffer is empty

    if ( aMm.Size() == 0 )

        {

        // delete entry - if we go back to idle state, we can create new entry

        DeleteCurrentEntryL();

        iState = EIdle;

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );

        return;

        }

    iClientEntryWrapper->SetCurrentEntry( iEntryBeingHandled );

    iDecoder->StartL( *iClientEntryWrapper, *iMmsHeaders, aMm, iStatus);

    *iClientStatus = KRequestPending;

    iState = EFinalizeDecodedMM;

    SetActive();   

    }

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

// CMmsCodecClient::DeleteMM

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

//

EXPORT_C TInt CMmsCodecClient::DeleteMM(

    TMsvId aMmId )

    {

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMML -function is allowed to 

    //be called after the new entry has been created.

    ResetChunkedMode();

    if ( iState == EEntryCreated ) 

        {

        iClientEntryWrapper->DeleteEntry( iEntryBeingHandled ); 

        iState = EIdle;  //No more new entry

        return KErrArgument;                      

        }   

    //The wrapper sets the entry to parent for us    

    return iClientEntryWrapper->DeleteEntry( aMmId ); 

    }

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

// CMmsCodecClient::RetrieveMML

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

//

EXPORT_C void CMmsCodecClient::RetrieveMML(

    TMsvId aMmId,

    CBufFlat& aMM,

    TMsvId& aFolder,

    TUint32& aFlags,                   

    TBool& aUnread,

    TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;

    ResetChunkedMode();

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMM -function is allowed to 

    //be called after the new entry has been created.

    if ( iState == EEntryCreated ) 

        {

        // delete entry

        DeleteCurrentEntryL();

        iState = EIdle;  //No more new entry

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                      

        return;

        }

    iEntryBeingHandled = aMmId;

    CBufFlat*   encodeBuffer = &aMM;

    iClientEntry->SetEntryL( aMmId ); 

    TMsvEntry tEntry = iClientEntry->Entry();

    // Get the flags of the entry.

    RetrieveFlags( tEntry, aFlags, aUnread );

    // Get the folder where the message is stored.

    aFolder = tEntry.Parent();

    tEntry.SetReadOnly( EFalse );

    iClientEntry->ChangeL( tEntry );

    // Prepare MMS headers for encoding.

    // Gets the message store for the current context with read access.

    CMsvStore* store = iClientEntry->ReadStoreL();

    CleanupStack::PushL( store );

    iMmsHeaders->RestoreL( *store );

    iMmsHeaders->SetMessageType( KMmsMessageTypeMSendReq );

    // Set MMS version if it is undefined

    if ( iMmsHeaders->MmsVersion() == 0 )

        {

        // Version not set

        iMmsHeaders->SetMmsVersion( iMmsVersion );

        }

    // Don't change the original message.

    CleanupStack::PopAndDestroy( store ); 

    // Encode the MMS.

    iClientEntryWrapper->SetCurrentEntry( aMmId );

    iEncoder->StartL( *iClientEntryWrapper, *iMmsHeaders, *encodeBuffer, iStatus );

    *iClientStatus = KRequestPending;

    iState = EFinalizeEncodedMM;

    SetActive();

    }

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

// CMmsCodecClient::SendMML

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

//

EXPORT_C CMsvOperation* CMmsCodecClient::SendMML(

    TMsvId aMmId ,

    TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;

    ResetChunkedMode();

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMM -function is allowed to 

    //be called after the new entry has been created.

    if ( iState == EEntryCreated ) 

        {

        // delete entry

        DeleteCurrentEntryL();   

        iState = EIdle;  //No more new entry

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                      

        return NULL;

        }

    iMmsClient->SwitchCurrentEntryL(aMmId);

    iMmsClient->LoadMessageL();

    CMsvOperation* op = NULL;   

    op = iMmsClient->SendL(iStatus);

    *iClientStatus = KRequestPending;

    iState = ESendMM;

    SetActive();   

    return op;

    }

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

// CMmsCodecClient::ReplaceMML

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

//

EXPORT_C void CMmsCodecClient::ReplaceMML(

    TMsvId& aMmId, 

    CBufFlat& aMm,

    TUint32 aFlags,

    TBool aUnread,

    TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;

    ResetChunkedMode();

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMM -function is allowed to 

    //be called after the new entry has been created.

    if ( iState == EEntryCreated ) 

        {

        // delete entry

        DeleteCurrentEntryL();   

        iState = EIdle;  //No more new entry

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                      

        return;

        }

    // Check if the aMm is empty. 

    if ( aMm.Size() == 0 )

        {

        iState = EIdle;

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );

        return;

        }

    // Messages in outbox must not be replaced.

    if ( ParentOutbox( aMmId ) )

        {

        iState = EIdle;

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );

        return;        

        }

    iFlags = aFlags;

    iUnread = aUnread;

    // Set the Entry as being handled

    iEntryBeingHandled = aMmId;

    iClientEntry->SetEntryL( iEntryBeingHandled );

    TMsvEntry tEntry = iClientEntry->Entry();

    tEntry.SetVisible( EFalse );

    tEntry.SetComplete( EFalse );

    tEntry.SetInPreparation( ETrue );

    tEntry.SetReadOnly( EFalse );

    iClientEntry->ChangeL( tEntry );

    // Remove the attachments of the Entry   

    CMsvStore* store = iClientEntry->EditStoreL();

    CleanupStack::PushL( store );

    MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

    MMsvAttachmentManagerSync& attachManSynch = store->AttachmentManagerExtensionsL(); 

    TInt numOfAttach( attachMan.AttachmentCount() );

    TInt i(0);

    while ( i < numOfAttach )

        {

    	attachManSynch.RemoveAttachmentL( 0 );  //This is correct

        i++;

        }

    store->CommitL();

    CleanupStack::PopAndDestroy( store );

    iClientEntryWrapper->SetCurrentEntry( iEntryBeingHandled );

    iDecoder->StartL( *iClientEntryWrapper, *iMmsHeaders, aMm, iStatus);

    *iClientStatus = KRequestPending;

    iState = EFinalizeDecodedMM;

    SetActive(); 

    }

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

// CMmsCodecClient::MoveMML

// This function is implemeted synchronously altought the interface looks like

// asynchronous

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

//

EXPORT_C void CMmsCodecClient::MoveMML( TMsvId aMmId, 

                               TMsvId aParentId, 

                               TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;

    ResetChunkedMode();

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMM -function is allowed to 

    //be called after the new entry has been created.

    if ( iState == EEntryCreated ) 

        {

        // delete entry

        DeleteCurrentEntryL();

        iState = EIdle;  //No more new entry

         *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                    

        return;

        }

    iState = EIdle;  //Move is stateless operation

    if ( aParentId == KMsvGlobalOutBoxIndexEntryId )

        {

    	 *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                    

        return;

        }

    iClientEntry->SetEntryL( aMmId );

    TMsvEntry tEntry = iClientEntry->Entry();

    TMsvId parent = tEntry.Parent();

    // Can't move within same folder

    if ( parent == aParentId )

        {

        *iClientStatus = KRequestPending;

        User::RequestComplete( iClientStatus, KErrArgument );                    

        return;	

        }

    iClientEntry->SetEntryL( parent );

    iClientEntry -> MoveL( aMmId, aParentId );

    //Let's accept all kind of moves between standard folders except to outbox 

    //altought all of them are not accepted from the mms ui of the phone

    //Some flags in TMsvEntry must be set according to target folder.

    TMmsMsvEntry* mmsEntry = STATIC_CAST( TMmsMsvEntry*, &tEntry );

    if ( aParentId == KMsvGlobalInBoxIndexEntryId )

        {

        mmsEntry->SetMobileTerminated( ETrue );

        tEntry.SetReadOnly( ETrue );

        } 

    else if ( aParentId == KMsvSentEntryId )

        {

        mmsEntry->SetMobileTerminated( EFalse );  

        tEntry.SetReadOnly( ETrue );

        }

    else // ( aParentId == KMsvDraftEntryId )

        {

        mmsEntry->SetMobileTerminated( EFalse );   

        tEntry.SetReadOnly( EFalse );

        // Messages in drafts folders must be always editor oriented.

        tEntry.iMtmData1 &= (~KMmsMessageMobileTerminated);

        tEntry.iMtmData1 |= KMmsMessageEditorOriented; // editor oriented    

        }

    *iClientStatus = KRequestPending;

    User::RequestComplete( iClientStatus, KErrNone );              

    }    

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

// CMmsCodecClient::SetFlags 

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

//

EXPORT_C TInt CMmsCodecClient::SetFlags(

    TMsvId aMmId,

    TUint32 aFlags,

    TBool aUnread )

    {

    TInt error( KErrNone );

    ResetChunkedMode();

    //Let's first make sure that the client is not illegally trashing the 

    //message store with empty entries. Only the AddMM -function is allowed to