/*

* 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:  

*      CMsvOperation class for MMS message creation.

*

*/

// INCLUDE FILES

#include    <msvids.h>

#include    <msvstore.h>

#include    <mtmdef.h>

#include    <mtmuids.h> 

#include    <mmsvattachmentmanager.h>

#include    <cmsvattachment.h>

#include    <cmsvmimeheaders.h>

#include    "mmsmessageoperation.h"

#include    "mmsconst.h"

#include    "mmssettings.h"

#include    "mmsheaders.h"

#include    "mmsgenutils.h"

#include    "mmsownnumber.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

extern void gPanic( TMmsPanic aPanic );

// CONSTANTS

const TInt KMmsRecipientGranularity = 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.

//

CMmsMessageOperation::~CMmsMessageOperation()

    {

    Cancel();

    delete iSourceStore;

    delete iTargetStore;

    delete iSourceEntry;

    delete iTargetEntry;

    delete iMsvOperation;

    delete iSettings;

    delete iNewMmsHeaders;

    delete iDescription;

    }

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

// CMmsMessageOperation::CreateNewL

//

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

EXPORT_C CMmsMessageOperation* CMmsMessageOperation::CreateNewL(

    TRequestStatus& aObserverRequestStatus,

    CMsvSession& aMsvSession,

    TMsvId aDestination,

    TMsvId aServiceId,

    TBool  aVisible,

    TBool  aInPreparation )

    {

    TMsvPartList parts = 0;

    CMmsMessageOperation* self = new(ELeave) CMmsMessageOperation(

        aObserverRequestStatus,

        aMsvSession,

        aDestination,

        parts,

        aServiceId,

        aVisible,

        aInPreparation );

    CleanupStack::PushL( self );

    self->ConstructL( KMsvNullIndexEntryId, ENew );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsMessageOperation::CreateReplyL

//

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

EXPORT_C CMmsMessageOperation* CMmsMessageOperation::CreateReplyL(

    TRequestStatus& aObserverRequestStatus,

    CMsvSession& aMsvSession,

    TMsvId aMessageId,

    TMsvId aDestination,

    TMsvPartList aPartList,

    TMsvId aServiceId,

    TBool  aVisible,

    TBool  aInPreparation )

    {

    if ( aMessageId == KMsvNullIndexEntryId )

        {

        // if no source cannot reply

        User::Leave( KErrArgument );

        }

    // Set the attachment part flag off

    TMsvPartList parts = aPartList & ~KMsvMessagePartAttachments;

    CMmsMessageOperation* self = new(ELeave) CMmsMessageOperation(

        aObserverRequestStatus,

        aMsvSession,

        aDestination,

        parts,

        aServiceId,

        aVisible,

        aInPreparation );

    CleanupStack::PushL( self );

    self->ConstructL( aMessageId, EReply );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsMessageOperation::CreateForwardL

//

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

EXPORT_C CMmsMessageOperation* CMmsMessageOperation::CreateForwardL(

    TRequestStatus& aObserverRequestStatus,

    CMsvSession& aMsvSession,

    TMsvId aMessageId,

    TMsvId aDestination,

    TMsvPartList aPartList,

    TMsvId aServiceId,

    TBool  aVisible,

    TBool  aInPreparation )

    {

    if ( aMessageId == KMsvNullIndexEntryId )

        {

        // if no source cannot forward

        User::Leave( KErrArgument );

        }

    // Set the attachment part flag on

    TMsvPartList parts = aPartList | KMsvMessagePartAttachments;

    CMmsMessageOperation* self = new(ELeave) CMmsMessageOperation(

        aObserverRequestStatus,

        aMsvSession,

        aDestination,

        parts,

        aServiceId,

        aVisible,

        aInPreparation );

    CleanupStack::PushL( self );

    self->ConstructL( aMessageId, EForward );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsMessageOperation::CreateForwardWithoutRetrievalL

//

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

//

EXPORT_C TMsvId CMmsMessageOperation::CreateForwardWithoutRetrievalL( 

    CMsvSession& aMsvSession,

    const CMmsHeaders& aNotificationHeaders,

    const TMsvId aRelatedEntry,

    const TMsvId aDestination,

    TMsvId aServiceId,

    TBool  aVisible,

    TBool  aInPreparation )

    {

    //

    // Create entry

    //

    TMsvEntry entry;

    CMsvEntry* cMsvEntry = CMsvEntry::NewL( 

        aMsvSession, aDestination, TMsvSelectionOrdering() );

    CleanupStack::PushL( cMsvEntry );

    entry.iType = KUidMsvMessageEntry;

    entry.iServiceId = aServiceId;

    entry.iMtm = KUidMsgMMSNotification;

    entry.iMtmData1 |= KMmsMessageForwardReq;

    entry.iDate.UniversalTime();

    entry.SetInPreparation( aInPreparation );    

    entry.SetVisible( aVisible );

    cMsvEntry->CreateL( entry );

    //

    // Get MMS settings

    //

    CMmsSettings* settings = CMmsSettings::NewL();

    CleanupStack::PushL( settings );

    settings->LoadSettingsL();

    //

    // Create headers object

    //

    CMmsHeaders* headers = CMmsHeaders::NewL( settings->MmsVersion() );

    CleanupStack::PushL( headers );

    headers->SetSettings( settings );

    //

    // Set ContentLocation to headers object

    //

    headers->SetContentLocationL( aNotificationHeaders.ContentLocation() );

    headers->SetRelatedEntry( aRelatedEntry );

    // Following entries are copied to the forward request on purpose

    // even though they do not belong to the PDU sent to the network

    headers->SetSubjectL( aNotificationHeaders.Subject() );

    headers->SetMessageSize( aNotificationHeaders.MessageSize() );   

    headers->SetMessageClass( aNotificationHeaders.MessageClass() );

    headers->SetMessagePriority( aNotificationHeaders.MessagePriority() );

    // Set Report Allowed according to settings

    headers->SetReportAllowed( settings->DeliveryReportSendingAllowed() );

    //

    // Check diskspace before storing headers

    //

    RFs fs = aMsvSession.FileSession();

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(

        &fs, 

        headers->Size(),

        aMsvSession.CurrentDriveL() ) )

        {

        User::Leave( KErrDiskFull );

        }

    //

    // Store headers to MessageStore

    //

    cMsvEntry->SetEntryL( entry.Id() );

    CMsvStore* store = cMsvEntry->EditStoreL();

    CleanupStack::PushL( store );   // ***

    headers->StoreL( *store );

    store->CommitL();

    //

    // Update and save index entry

    //

    entry.iSize = headers->Size();

    cMsvEntry->ChangeL( entry );

    CleanupStack::PopAndDestroy( store );

    CleanupStack::PopAndDestroy( headers );

    CleanupStack::PopAndDestroy( settings );

    CleanupStack::PopAndDestroy( cMsvEntry );

    return entry.Id();

    }

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

// CMmsMessageOperation::ConstructL

//

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

void CMmsMessageOperation::ConstructL( 

            TMsvId aMessageId, 

            TMmsOperation aOperation )

    {

    iOrigMessageId = aMessageId;

    iOperation = aOperation;

    iDataMember = KMsvNullIndexEntryId;

    iState = ECreateMmsHeaders;

    iAttachmentsSize = 0;

    iDescription = NULL;

    iOriginalRoot = 0;

    iAttachmentCount = 0;

    iNewRoot = -1; // not found yet

    // Create new message entry object to work with

    // iDestinationId is the target folder

    iTargetEntry = CMsvEntry::NewL( 

        iMsvSession, iDestinationId, TMsvSelectionOrdering() );

    // Show invisible entries too.

    iTargetEntry->SetSortTypeL( TMsvSelectionOrdering( 

        KMsvNoGrouping, EMsvSortByNone, ETrue ));

    if ( iOrigMessageId != KMsvNullIndexEntryId )

        {

        // Create entry for the original entry

        iSourceEntry = CMsvEntry::NewL( 

            iMsvSession, iOrigMessageId, TMsvSelectionOrdering() );

        // Show invisible entries too.

        iSourceEntry->SetSortTypeL( TMsvSelectionOrdering( 

            KMsvNoGrouping, EMsvSortByNone, ETrue ));

        // if we have an original entry, it will be read    

        iSourceStore = iSourceEntry->ReadStoreL();    

        }

    iSettings = CMmsSettings::NewL();

    // Add this objet to the scheduler

    CActiveScheduler::Add( this );

    ChangeStateL();

    iObserverRequestStatus = KRequestPending;

    SetActive();

    }

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

// CMmsMessageOperation::FinalProgress

//

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

//

EXPORT_C const TDesC8& CMmsMessageOperation::FinalProgress()

   {

    __ASSERT_ALWAYS( !IsActive(), gPanic( EMmsActiveInFinalProgress ));

    const TDesC8* progress = &KNullDesC8();

    TRAPD( leave, {progress = &ProgressL();} );

    __ASSERT_ALWAYS( leave == KErrNone, gPanic( EMmsFinalProgressFailed ));

    return *progress;

   }

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

// CMmsMessageOperation::ProgressL

//

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

//

const TDesC8& CMmsMessageOperation::ProgressL()

   {

   if (iState == EFinished )

       {

       iDataMember() = iNewMessageId;

       }

   return iDataMember;

   }

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

// CMmsMessageOperation::RunL

//

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

//

void CMmsMessageOperation::RunL()

    {

    if (iStatus.Int() != KErrNone )

        {

        ErrorRecovery( iStatus.Int() );

        return;

        }

    // Check the progress status in case that real progress is available.

    // only entry creation returns correct progress info

    if ( iState == ECreateMessageEntry ) 

        {

        TMsvLocalOperationProgress  progress = 

            McliUtils::GetLocalProgressL( *iMsvOperation );

        if ( progress.iError != KErrNone )

            {

            ErrorRecovery( progress.iError );

            return;

            }

        }

    if ( iState != EFinished )

        {

        TRAPD( error, SelectAndChangeToNextStateL() );

        if ( error )

            {

            ErrorRecovery( error );

            return;

            }

        else if ( iState != EFinished )

            {

            // Here we go again.

            SetActive();

            }

        else

            {

            // keep LINT happy

            }

        }

    }

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

// CMmsMessageOperation::CMmsMessageOperation

//

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

CMmsMessageOperation::CMmsMessageOperation(

    TRequestStatus& aObserverRequestStatus, 

    CMsvSession& aMsvSession, 

    TMsvId aDestination, 

    TMsvPartList aPartList,

    TMsvId aServiceId,

    TBool aVisible,

    TBool  aInPreparation )

    : CMsvOperation( aMsvSession, EPriorityStandard, aObserverRequestStatus ),

      iDestinationId( aDestination ),

      iPartList( aPartList ),

      iServiceId( aServiceId ),

      iSettings( NULL ),

      iNewMmsHeaders( NULL ),

      iVisible( aVisible ),

      iInPreparation ( aInPreparation )

    {

    }

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

// CMmsMessageOperation::ErrorRecovery

//

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

void CMmsMessageOperation::ErrorRecovery( TInt aError )

    {

    // Delete entry and store objects associated with the new entry.

    // If an error is encountered, store is not committed, and the

    // entry under construction is deleted.

    // Deleting the message entry deletes all attachments that are

    // stored in the message store. Linked attachments are not deleted.

    delete iTargetStore;

    iTargetStore = NULL;

    delete iTargetEntry;

    iTargetEntry = NULL;

    // Remove the new message entry

    if ( iNewMessageId != KMsvNullIndexEntryId )

        {

        iMsvSession.RemoveEntry( iNewMessageId );

        }

    delete iSourceStore;

    iSourceStore = NULL;

    delete iSourceEntry;

    iSourceEntry = NULL;

    // complete the observer with error

    TRequestStatus* status = &iObserverRequestStatus;

    User::RequestComplete( status, aError );

    }

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

// CMmsMessageOperation::ChangeStateL

//

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

void CMmsMessageOperation::ChangeStateL()

    {

    switch (iState)

        {

        case ECreateMmsHeaders:

            CreateNewMmsHeaderL();

            break;

        case ECreateMessageEntry:

            CreateMessageEntryL();

            break;

        case ECopyAttachments:

            CopyAttachmentsL();

            // Attachments are copied one by one.

            // We stay in ECopyAttachment state until all attachments have

            // been handled.

            iCurrentAttachment++;

            break;

        case EStoreMmsHeaders:

            StoreMmsHeadersL();

            break;

        case ECompleteMessage:

            CompleteMessageL();

            break;

        case EFinished:

            {

            TRequestStatus* status = &iObserverRequestStatus;

            User::RequestComplete( status, KErrNone );

            }

            break;

        default:

            // We are never supposed to be here.

            User::LeaveIfError( KErrNotSupported );

            break;

        }

    }

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

// CMmsMessageOperation::RequestComplete

//

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

void CMmsMessageOperation::RequestComplete( TInt aError )

    {

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, aError );

    }

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

// CMmsMessageOperation::SelectNextStateL

//

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

void CMmsMessageOperation::SelectNextStateL()

    {

    switch (iState)

        {

        case ECreateMmsHeaders:

            iState = ECreateMessageEntry;

            break;

        case ECreateMessageEntry:

            {

            // Get the id of new entry

            TMsvLocalOperationProgress progress = 

                McliUtils::GetLocalProgressL( *iMsvOperation );

            iNewMessageId = progress.iId;

            iTargetEntry->SetEntryL( iNewMessageId );

            iTargetStore = iTargetEntry->EditStoreL();

            }

            // Fall through on purpose.

            // Attachment are copied before MMS headers are saved

            // so that we can adjust the root attachment id.

            // If the message has no attachments, we proceed directly

            // to saving MMS headers.

        case ECopyAttachments: