/*

* 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:  State machine -based operation for restoring attached messages.

*

*/

// INCLUDE FILES

#include "cmsgmailrestoreattmsgsop.h"

#include "MsgMailEditorDocument.h"

#include "MailLog.h"

#include <MsgEditorAppUi.rsg>       // resource identifiers

#include <MsgMailEditor.rsg>

#include <MsgAttachmentModel.h>

_LIT8(KMessageMimeType, "message/rfc822");

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

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

// CMsgMailRestoreAttMsgsOp::CMsgMailRestoreAttMsgsOp

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

// might leave.

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

//

CMsgMailRestoreAttMsgsOp::CMsgMailRestoreAttMsgsOp(

    CMsgMailEditorDocument& aDocument )

    : CMsgMailBaseOp( aDocument )

    {

    }

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

// CMsgMailRestoreAttMsgsOp::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMsgMailRestoreAttMsgsOp::ConstructL()

    {

    }

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

// CMsgMailRestoreAttMsgsOp::NewL

// Two-phased constructor.

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

//

CMsgMailRestoreAttMsgsOp* CMsgMailRestoreAttMsgsOp::NewL(

    CMsgMailEditorDocument& aDocument )

    {

    CMsgMailRestoreAttMsgsOp* self =

        new( ELeave ) CMsgMailRestoreAttMsgsOp( aDocument );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMsgMailRestoreAttMsgsOp::~CMsgMailRestoreAttMsgsOp()

    {

    LOG( "CMsgMailRestoreAttMsgsOp::~CMsgMailRestoreAttMsgsOp" );

    Cancel();

    }

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

// CMsgMailRestoreAttMsgsOp::HandleStateActionL

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

//

void CMsgMailRestoreAttMsgsOp::HandleStateActionL()

    {

    switch ( iState )

        {

        case EGetMsgDigestEntries:

            {

            GetMsgDigestEntriesL();

            break;

            }

        case EPrepareAddAttMsgs:

            {

            PrepareAddAttMsgsL();

            break;

            }

        case EAddAttMsgs:

            {

            AddAttMsgsL();

            break;

            }                               

        default:

            {

            // should never come here

            ASSERT( EFalse );

            break;

            }

        }

    }

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

// CMsgMailRestoreAttMsgsOp::SetNextState

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

//

void CMsgMailRestoreAttMsgsOp::SetNextState()

    {

    switch ( iState )

        {

        case EIdleState:

            {

            iState = EGetMsgDigestEntries;

            break;

            }

        case EGetMsgDigestEntries:

            {

            iState = EPrepareAddAttMsgs;

            break;

            }

        case EPrepareAddAttMsgs: // fall through

        case EAddAttMsgs:

            {

            if ( iIndex < iEntries->Count() )

                {

                iState = EAddAttMsgs;

                }

            else

                {

                iState = EIdleState;

                }

            break;

            }            

        default:

            {            

            iState = EIdleState;

            break;

            }

        }        

    }

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

// CMsgMailRestoreAttMsgsOp::HandleOperationCancel

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

//

void CMsgMailRestoreAttMsgsOp::HandleOperationCancel()

    {

    LOG( "CMsgMailRestoreAttMsgsOp::HandleOperationCancel" );

    if ( iState == EGetMsgDigestEntries )

        {

        LOG( "HandleOperationCancel, canceling message operation" );

        TRAP_IGNORE( iDocument.MessageL().Cancel() );

        }

    }

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

// CMsgMailRestoreAttMsgsOp::HandleStateActionError

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

//

TBool CMsgMailRestoreAttMsgsOp::HandleStateActionError( TInt /*aError*/ )

    {

    TBool retVal( EFalse );

    LOG( "CMsgMailRestoreAttMsgsOp::HandleStateActionError" );

    if ( iState == EAddAttMsgs )

        { // record the problem and return ETrue to indicate that operation

          // can be continued

        iInvalidAttaMsgCount++;

        retVal = ETrue;

        }

    return retVal;

    }

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

// CMsgMailRestoreAttMsgsOp::GetMsgDigestEntriesL

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

//    

void CMsgMailRestoreAttMsgsOp::GetMsgDigestEntriesL()

    {    

    iDocument.MessageL().GetMessageDigestEntriesL( iStatus,

                                                   iDocument.Entry().Id() );

    SetActive();

    }

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

// CMsgMailRestoreAttMsgsOp::PrepareAddAttMsgsL

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

//    

void CMsgMailRestoreAttMsgsOp::PrepareAddAttMsgsL()

    {    

    iEntries = &( iDocument.MessageL().Selection() );

    // initialize counters and index

    iAllAttaMsgCount = iEntries->Count();

    iInvalidAttaMsgCount = 0;    

    iIndex = 0;

    CompleteStateAction();

    }

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

// CMsgMailRestoreAttMsgsOp::AddAttMsgsL

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

//    

void CMsgMailRestoreAttMsgsOp::AddAttMsgsL()

    {    

    DoAddAttMsgL( iIndex );

    iIndex++; // increase index for next iteration

    CompleteStateAction();

    }    

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

// CMsgMailRestoreAttMsgsOp::DoAddAttMsgL

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

//    

void CMsgMailRestoreAttMsgsOp::DoAddAttMsgL( TInt aIndex ) const

    {

    ASSERT( iEntries && aIndex < iEntries->Count() );

    const TDataType messageMimeType( KMessageMimeType );

    const TMsvId messId( iEntries->At( aIndex ) );

    CMsvEntry* parententry= iDocument.Session().GetEntryL( messId );

    CleanupStack::PushL( parententry );

    const TMsvEntry entry( parententry->Entry() );

    iDocument.AttachmentModel().AddAttachmentL( entry.iDescription,

                                                entry.iSize,

                                                messId,

                                                entry.Complete(),

                                                messageMimeType );

    CleanupStack::PopAndDestroy(parententry); // parententry

    }        

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

// CMsgMailRestoreAttMsgsOp::CountAllAttaMsgs

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

//    

TInt CMsgMailRestoreAttMsgsOp::CountAllAttaMsgs() const

    {

    return iAllAttaMsgCount;

    }

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

// CMsgMailRestoreAttMsgsOp::CountInvalidAttaMsgs

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

//    

TInt CMsgMailRestoreAttMsgsOp::CountInvalidAttaMsgs() const

    {

    return iInvalidAttaMsgCount;

    }

// End Of File