/*
* 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 fetching files as attachments.
*
*/



// INCLUDE FILES
#include "cmsgmailfetchfileop.h"
#include "MsgMailEditorDocument.h"
#include "MailLog.h"
#include "Msgattachmentverifier.h"
#include "cmsgmailrestoresuperop.h"
#include "MailUtils.h"
#include <MsgEditorAppUi.rsg>
#include <MsgMailEditor.rsg>
#include <coemain.h>
#include <mmsvattachmentmanager.h>

// LOCAL CONSTANT

// appoximated 3 attachments / message
const TInt KFetchFileGranularity = 3;

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

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::CMsgMailFetchFileOp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMsgMailFetchFileOp::CMsgMailFetchFileOp(
    MsgAttachmentUtils::TMsgAttachmentFetchType aFetchType,
    CMsgMailEditorDocument& aDocument )
    : CMsgMailBaseOp( aDocument ),
      iFetchType( aFetchType )
    {
    //We set a higher priority to fetch op so that touch events won´t get
    //leaked to editors toolbar
    SetPriority( EActivePriorityWsEvents + 1 );
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::ConstructL()
    {
    LOG( "CMsgMailFetchFileOp::ConstructL" );
    iFetchArray = new( ELeave ) CDesCArrayFlat( KFetchFileGranularity );
    iManager = &( iDocument.GetAttachmentManagerL() );
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMsgMailFetchFileOp* CMsgMailFetchFileOp::NewL(
    MsgAttachmentUtils::TMsgAttachmentFetchType aFetchType,
    CMsgMailEditorDocument& aDocument )
    {
    CMsgMailFetchFileOp* self =
        new( ELeave ) CMsgMailFetchFileOp( aFetchType, aDocument );
    CleanupStack::PushL( self );
    self->ConstructL();

    CleanupStack::Pop(self);
    return self;
    }

// Destructor
CMsgMailFetchFileOp::~CMsgMailFetchFileOp()
    {
    LOG( "CMsgMailFetchFileOp::~CMsgMailFetchFileOp" );
    if( iBlocker )
        {
		// iBlocker is deleted in AknInputBlockCancel
        iBlocker->Cancel();
        }
    Cancel();
    delete iFetchArray;
    delete iRestoreSuperOp;
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::HandleStateActionL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::HandleStateActionL()
    {
    switch ( iState )
        {
        case ESelectFiles:
            {
            SelectFilesL();
            break;
            }
        case EAddAttas:
            {
            AddAttasL();
            break;
            }
        case ERestoreAllAttas:
            {
            RestoreAllAttasL();
            break;
            }
        case EFinalize:
            {
            FinalizeL();
            break;
            }
        default:
            {
            // should never come here
            ASSERT( EFalse );
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::SetNextState
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::SetNextState()
    {
    switch ( iState )
        {
        case EIdleState:
            {
            iState = ESelectFiles;
            break;
            }
        case ESelectFiles:
            {
            iState = EAddAttas;
            break;
            }
        case EAddAttas:
            {
            iState = ERestoreAllAttas;
            break;
            }
        case ERestoreAllAttas:
            {
            iState = EFinalize;
            break;
            }
        case EFinalize:
        default:
            {
            iState = EIdleState;
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::HandleOperationCancel
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::HandleOperationCancel()
    {
    LOG( "CMsgMailFetchFileOp::HandleOperationCancel, deleting iRestoreSuperOp" );
    if( iBlocker )
        {
        iBlocker->Cancel();
        }
    delete iRestoreSuperOp;
    iRestoreSuperOp = NULL;
    if ( iState == EAddAttas )
        {
        // cancel possibly ongoing AddAttachmentL() request, doesn't do
        // anything if request isn't outstanding
        LOG( "HandleOperationCancel, cancel manager's request" );
        iManager->CancelRequest();
        }
    LOG( "HandleOperationCancel, ...finished" );
    }


// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::AknInputBlockCancel
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::AknInputBlockCancel()
    {
    delete iBlocker;
    iBlocker = NULL;
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::SelectFilesL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::SelectFilesL()
    {
    TInt fetchResult( EFalse );

    // starting phase -> initialize operation data
    iFetchCount = 0;
    iFileName = KNullDesC;
    iFetchArray->Reset();

    CMsgAttachmentVerifier* verifier =
        CMsgAttachmentVerifier::NewLC( iDocument.Session() );

    if ( iFetchType == MsgAttachmentUtils::EUnknown )
    	{
    	if ( MsgAttachmentUtils::FetchAnyFileL( iFileName,
    	                                        *( CCoeEnv::Static() ),
    	                                        verifier ) )
    	    {
    	    fetchResult = ETrue;
    	    iFetchCount = 1;
    	    }
    	}
    else
    	{
    	fetchResult = MsgAttachmentUtils::FetchFileL( iFetchType,
                                        iFileName,
    	                                *iFetchArray,
    	                                ETrue,
    	                                EFalse,
    	                                verifier );
    	iFetchCount = iFetchArray->Count();
       	}
	// Check fetch results. EFalse if user cancels the fetch.
    if ( fetchResult == EFalse )
        {
        User::Leave( KErrCancel );
        }
    CleanupStack::PopAndDestroy( verifier ); // verifier
    CompleteStateAction();
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::AddAttasL
// In current implementation multiple attachments are added as a one step, and
// failure with one attachment interrupts entire procedure.
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::AddAttasL()
    {
    StartWaitNoteL( R_WAIT_INSERTING_ATTACHMENT, EFalse, R_MEB_WAIT_NOTE );
    ASSERT( iFetchCount > 0 ); // op was cancelled if nothing was selected
    
	if( iBlocker )
        {
        iBlocker->Cancel();
        }
    // NewL version does not exist
    iBlocker = CAknInputBlock::NewCancelHandlerLC( this ); 
    CleanupStack::Pop( iBlocker );

    if ( iFetchCount > 1 )
    	{
    	AddMultipleAttachmentsL( *iFetchArray, iDocument, iStatus );
    	}
    else
        {
        AddSingleAttachmentL( iFileName, iDocument, iStatus );
        }
    SetActive();
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::RestoreAllAttasL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::RestoreAllAttasL()
    {
    delete iRestoreSuperOp;
    iRestoreSuperOp = NULL;
    iRestoreSuperOp = CMsgMailRestoreSuperOp::NewL( iDocument );
    iRestoreSuperOp->StartOp( iStatus );
    SetActive();
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::FinalizeL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::FinalizeL()
    {
    StopWaitNote();
    if( iBlocker )
        {
        iBlocker->Cancel();
        }
    
    TBool invalidAttas = iRestoreSuperOp->ShowNoteIfInvalidAttaL();
    TBool drmAttas = iRestoreSuperOp->ShowNoteIfDRMAttaL();
    if ( !invalidAttas && !drmAttas )
        { // Restore operation reported no problems so we determine that the
          // attachment was really added. Note that we actually restored ALL
          // the attachments and some of them could have theoretically reported
          // a problem, but in practise this should correctly indicate the
          // success of attachment adding operation.
        MailUtils::ConfirmationNoteL( R_MAIL_EDITOR_ADDED_ATTACH_TEXT );
        }
    CompleteStateAction();
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::AddMultipleAttachmentsL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::AddMultipleAttachmentsL(
    CDesCArray& aAttachments,
    CMsgMailEditorDocument& aDocument,
    TRequestStatus& aStatus ) const
    {
    TInt count( aAttachments.Count() );
    for ( TInt i( 0 ); i < count; i++ )
        {
        TPtrC attaName = aAttachments.MdcaPoint( i );
        AddSingleAttachmentL( attaName, aDocument, aStatus );
        }
    }

// -----------------------------------------------------------------------------
// CMsgMailFetchFileOp::AddSingleAttachmentL
// -----------------------------------------------------------------------------
//
void CMsgMailFetchFileOp::AddSingleAttachmentL(
    const TDesC& aAttachmentName,
    CMsgMailEditorDocument& /*aDocument*/,
    TRequestStatus& aStatus ) const
    {
    // Add attachment to message
    TInt attaSize( MailUtils::FileSize( aAttachmentName ) );
    User::LeaveIfError( attaSize );

    CMsvAttachment* info = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
    CleanupStack::PushL(info);

    // info needs to be updated before attachment
    // is saved to mail message.
    // Mime type needs to be set later, see RestoreAttachmentsL
    info->SetAttachmentNameL( aAttachmentName );
    info->SetSize( attaSize );
    iManager->AddAttachmentL( aAttachmentName, info, aStatus );
    CleanupStack::Pop( info ); // info, ownership transferred
    }

// End Of File